From 17f211c393772f30922bac595592e3fe60c2ef25 Mon Sep 17 00:00:00 2001 From: Jesse Hallam Date: Fri, 13 Jul 2018 10:29:50 -0400 Subject: MM-11292: clean up plugins GoDoc (#9109) * clean up plugins GoDoc: - eliminate plugin.NewBlankContext() as unnecessary - export ValidIdRegex as a string vs. the less readable var - add/update various documentation strings - hide everything by default, except where used by client plugins or the mattermost-server. The exception to this rule are the `*(Args|Returns)` structs which must be public for go-plugin, but are now prefixed with `Z_` with a warning not to use. - include a top-level example to get plugin authors started This is not a breaking change for existing plugins compiled against plugins-v2. * remove commented out ServeHTTPResponseWriter * update examples to match developer docs * add missing plugin/doc.go license header --- plugin/api.go | 5 +- plugin/client.go | 22 +- plugin/client_rpc.go | 78 ++-- plugin/client_rpc_generated.go | 744 ++++++++++++++++++------------------- plugin/context.go | 10 + plugin/doc.go | 9 + plugin/environment.go | 79 ++-- plugin/example_hello_world_test.go | 20 + plugin/example_help_test.go | 71 ++++ plugin/hclog_adapter.go | 30 +- plugin/hooks.go | 17 +- plugin/http.go | 34 +- plugin/interface_generator/main.go | 29 +- plugin/io_rpc.go | 16 +- plugin/request_context.go | 11 - plugin/supervisor.go | 20 +- plugin/supervisor_test.go | 8 +- plugin/valid.go | 17 +- 18 files changed, 672 insertions(+), 548 deletions(-) create mode 100644 plugin/context.go create mode 100644 plugin/doc.go create mode 100644 plugin/example_hello_world_test.go create mode 100644 plugin/example_help_test.go delete mode 100644 plugin/request_context.go (limited to 'plugin') diff --git a/plugin/api.go b/plugin/api.go index 2b15a3d09..76df9377a 100644 --- a/plugin/api.go +++ b/plugin/api.go @@ -11,7 +11,8 @@ import ( // The API can be used to retrieve data or perform actions on behalf of the plugin. Most methods // have direct counterparts in the REST API and very similar behavior. // -// Plugins can obtain access to the API by implementing the OnActivate hook. +// Plugins obtain access to the API by embedding MattermostPlugin and accessing the API member +// directly. type API interface { // LoadPluginConfiguration loads the plugin's configuration. dest should be a pointer to a // struct that the configuration JSON can be unmarshalled to. @@ -178,7 +179,7 @@ type API interface { LogWarn(msg string, keyValuePairs ...interface{}) } -var Handshake = plugin.HandshakeConfig{ +var handshake = plugin.HandshakeConfig{ ProtocolVersion: 1, MagicCookieKey: "MATTERMOST_PLUGIN", MagicCookieValue: "Securely message teams, anywhere.", diff --git a/plugin/client.go b/plugin/client.go index 3f6fbc7a6..457a16cf4 100644 --- a/plugin/client.go +++ b/plugin/client.go @@ -7,8 +7,9 @@ import ( "github.com/hashicorp/go-plugin" ) -// Starts the serving of a Mattermost plugin over rpc or gRPC -// Call this when your plugin is ready to start +// Starts the serving of a Mattermost plugin over net/rpc. gRPC is not yet supported. +// +// Call this when your plugin is ready to start. func ClientMain(pluginImplementation interface{}) { if impl, ok := pluginImplementation.(interface { SetAPI(api API) @@ -21,28 +22,39 @@ func ClientMain(pluginImplementation interface{}) { } pluginMap := map[string]plugin.Plugin{ - "hooks": &HooksPlugin{hooks: pluginImplementation}, + "hooks": &hooksPlugin{hooks: pluginImplementation}, } plugin.Serve(&plugin.ServeConfig{ - HandshakeConfig: Handshake, + HandshakeConfig: handshake, Plugins: pluginMap, }) } type MattermostPlugin struct { - API API + // API exposes the plugin api, and becomes available just prior to the OnActive hook. + API API + selfRef interface{} // This is so we can unmarshal into our parent } +// SetAPI persists the given API interface to the plugin. It is invoked just prior to the +// OnActivate hook, exposing the API for use by the plugin. func (p *MattermostPlugin) SetAPI(api API) { p.API = api } +// SetSelfRef is called by ClientMain to maintain a pointer to the plugin interface originally +// registered. This allows for the default implementation of OnConfigurationChange. func (p *MattermostPlugin) SetSelfRef(ref interface{}) { p.selfRef = ref } +// OnConfigurationChange provides a default implementation of this hook event that unmarshals the +// plugin configuration directly onto the plugin struct. +// +// Feel free to implement your own version of OnConfigurationChange if you need more advanced +// configuration handling. func (p *MattermostPlugin) OnConfigurationChange() error { if p.selfRef != nil { return p.API.LoadPluginConfiguration(p.selfRef) diff --git a/plugin/client_rpc.go b/plugin/client_rpc.go index 39d91a3e7..ed76dc6e8 100644 --- a/plugin/client_rpc.go +++ b/plugin/client_rpc.go @@ -22,9 +22,9 @@ import ( "github.com/mattermost/mattermost-server/model" ) -var HookNameToId map[string]int = make(map[string]int) +var hookNameToId map[string]int = make(map[string]int) -type HooksRPCClient struct { +type hooksRPCClient struct { client *rpc.Client log *mlog.Logger muxBroker *plugin.MuxBroker @@ -32,33 +32,33 @@ type HooksRPCClient struct { implemented [TotalHooksId]bool } -type HooksRPCServer struct { +type hooksRPCServer struct { impl interface{} muxBroker *plugin.MuxBroker - apiRPCClient *APIRPCClient + apiRPCClient *apiRPCClient } // Implements hashicorp/go-plugin/plugin.Plugin interface to connect the hooks of a plugin -type HooksPlugin struct { +type hooksPlugin struct { hooks interface{} apiImpl API log *mlog.Logger } -func (p *HooksPlugin) Server(b *plugin.MuxBroker) (interface{}, error) { - return &HooksRPCServer{impl: p.hooks, muxBroker: b}, nil +func (p *hooksPlugin) Server(b *plugin.MuxBroker) (interface{}, error) { + return &hooksRPCServer{impl: p.hooks, muxBroker: b}, nil } -func (p *HooksPlugin) Client(b *plugin.MuxBroker, client *rpc.Client) (interface{}, error) { - return &HooksRPCClient{client: client, log: p.log, muxBroker: b, apiImpl: p.apiImpl}, nil +func (p *hooksPlugin) Client(b *plugin.MuxBroker, client *rpc.Client) (interface{}, error) { + return &hooksRPCClient{client: client, log: p.log, muxBroker: b, apiImpl: p.apiImpl}, nil } -type APIRPCClient struct { +type apiRPCClient struct { client *rpc.Client log *mlog.Logger } -type APIRPCServer struct { +type apiRPCServer struct { impl API } @@ -72,17 +72,17 @@ func init() { // These enforce compile time checks to make sure types implement the interface // If you are getting an error here, you probably need to run `make pluginapi` to // autogenerate RPC glue code -var _ plugin.Plugin = &HooksPlugin{} -var _ Hooks = &HooksRPCClient{} +var _ plugin.Plugin = &hooksPlugin{} +var _ Hooks = &hooksRPCClient{} // // Below are specal cases for hooks or APIs that can not be auto generated // -func (g *HooksRPCClient) Implemented() (impl []string, err error) { +func (g *hooksRPCClient) Implemented() (impl []string, err error) { err = g.client.Call("Plugin.Implemented", struct{}{}, &impl) for _, hookName := range impl { - if hookId, ok := HookNameToId[hookName]; ok { + if hookId, ok := hookNameToId[hookName]; ok { g.implemented[hookId] = true } } @@ -90,7 +90,7 @@ func (g *HooksRPCClient) Implemented() (impl []string, err error) { } // Implemented replies with the names of the hooks that are implemented. -func (s *HooksRPCServer) Implemented(args struct{}, reply *[]string) error { +func (s *hooksRPCServer) Implemented(args struct{}, reply *[]string) error { ifaceType := reflect.TypeOf((*Hooks)(nil)).Elem() implType := reflect.TypeOf(s.impl) selfType := reflect.TypeOf(s) @@ -130,24 +130,24 @@ func (s *HooksRPCServer) Implemented(args struct{}, reply *[]string) error { return nil } -type OnActivateArgs struct { +type Z_OnActivateArgs struct { APIMuxId uint32 } -type OnActivateReturns struct { +type Z_OnActivateReturns struct { A error } -func (g *HooksRPCClient) OnActivate() error { +func (g *hooksRPCClient) OnActivate() error { muxId := g.muxBroker.NextId() - go g.muxBroker.AcceptAndServe(muxId, &APIRPCServer{ + go g.muxBroker.AcceptAndServe(muxId, &apiRPCServer{ impl: g.apiImpl, }) - _args := &OnActivateArgs{ + _args := &Z_OnActivateArgs{ APIMuxId: muxId, } - _returns := &OnActivateReturns{} + _returns := &Z_OnActivateReturns{} if err := g.client.Call("Plugin.OnActivate", _args, _returns); err != nil { g.log.Error("RPC call to OnActivate plugin failed.", mlog.Err(err)) @@ -155,13 +155,13 @@ func (g *HooksRPCClient) OnActivate() error { return _returns.A } -func (s *HooksRPCServer) OnActivate(args *OnActivateArgs, returns *OnActivateReturns) error { +func (s *hooksRPCServer) OnActivate(args *Z_OnActivateArgs, returns *Z_OnActivateReturns) error { connection, err := s.muxBroker.Dial(args.APIMuxId) if err != nil { return err } - s.apiRPCClient = &APIRPCClient{ + s.apiRPCClient = &apiRPCClient{ client: rpc.NewClient(connection), } @@ -186,23 +186,23 @@ func (s *HooksRPCServer) OnActivate(args *OnActivateArgs, returns *OnActivateRet return nil } -type LoadPluginConfigurationArgs struct { +type Z_LoadPluginConfigurationArgsArgs struct { } -type LoadPluginConfigurationReturns struct { +type Z_LoadPluginConfigurationArgsReturns struct { A []byte } -func (g *APIRPCClient) LoadPluginConfiguration(dest interface{}) error { - _args := &LoadPluginConfigurationArgs{} - _returns := &LoadPluginConfigurationReturns{} +func (g *apiRPCClient) LoadPluginConfiguration(dest interface{}) error { + _args := &Z_LoadPluginConfigurationArgsArgs{} + _returns := &Z_LoadPluginConfigurationArgsReturns{} if err := g.client.Call("Plugin.LoadPluginConfiguration", _args, _returns); err != nil { g.log.Error("RPC call to LoadPluginConfiguration API failed.", mlog.Err(err)) } return json.Unmarshal(_returns.A, dest) } -func (s *APIRPCServer) LoadPluginConfiguration(args *LoadPluginConfigurationArgs, returns *LoadPluginConfigurationReturns) error { +func (s *apiRPCServer) LoadPluginConfiguration(args *Z_LoadPluginConfigurationArgsArgs, returns *Z_LoadPluginConfigurationArgsReturns) error { var config interface{} if hook, ok := s.impl.(interface { LoadPluginConfiguration(dest interface{}) error @@ -220,17 +220,17 @@ func (s *APIRPCServer) LoadPluginConfiguration(args *LoadPluginConfigurationArgs } func init() { - HookNameToId["ServeHTTP"] = ServeHTTPId + hookNameToId["ServeHTTP"] = ServeHTTPId } -type ServeHTTPArgs struct { +type Z_ServeHTTPArgs struct { ResponseWriterStream uint32 Request *http.Request Context *Context RequestBodyStream uint32 } -func (g *HooksRPCClient) ServeHTTP(c *Context, w http.ResponseWriter, r *http.Request) { +func (g *hooksRPCClient) ServeHTTP(c *Context, w http.ResponseWriter, r *http.Request) { if !g.implemented[ServeHTTPId] { http.NotFound(w, r) return @@ -247,7 +247,7 @@ func (g *HooksRPCClient) ServeHTTP(c *Context, w http.ResponseWriter, r *http.Re defer connection.Close() rpcServer := rpc.NewServer() - if err := rpcServer.RegisterName("Plugin", &HTTPResponseWriterRPCServer{w: w}); err != nil { + if err := rpcServer.RegisterName("Plugin", &httpResponseWriterRPCServer{w: w}); err != nil { g.log.Error("Plugin failed to ServeHTTP, coulden't register RPC name", mlog.Err(err)) http.Error(w, "500 internal server error", http.StatusInternalServerError) return @@ -266,7 +266,7 @@ func (g *HooksRPCClient) ServeHTTP(c *Context, w http.ResponseWriter, r *http.Re return } defer bodyConnection.Close() - ServeIOReader(r.Body, bodyConnection) + serveIOReader(r.Body, bodyConnection) }() } @@ -282,7 +282,7 @@ func (g *HooksRPCClient) ServeHTTP(c *Context, w http.ResponseWriter, r *http.Re RequestURI: r.RequestURI, } - if err := g.client.Call("Plugin.ServeHTTP", ServeHTTPArgs{ + if err := g.client.Call("Plugin.ServeHTTP", Z_ServeHTTPArgs{ Context: c, ResponseWriterStream: serveHTTPStreamId, Request: forwardedRequest, @@ -294,13 +294,13 @@ func (g *HooksRPCClient) ServeHTTP(c *Context, w http.ResponseWriter, r *http.Re return } -func (s *HooksRPCServer) ServeHTTP(args *ServeHTTPArgs, returns *struct{}) error { +func (s *hooksRPCServer) ServeHTTP(args *Z_ServeHTTPArgs, returns *struct{}) error { connection, err := s.muxBroker.Dial(args.ResponseWriterStream) if err != nil { fmt.Fprintf(os.Stderr, "[ERROR] Can't connect to remote response writer stream, error: %v", err.Error()) return err } - w := ConnectHTTPResponseWriter(connection) + w := connectHTTPResponseWriter(connection) defer w.Close() r := args.Request @@ -310,7 +310,7 @@ func (s *HooksRPCServer) ServeHTTP(args *ServeHTTPArgs, returns *struct{}) error fmt.Fprintf(os.Stderr, "[ERROR] Can't connect to remote request body stream, error: %v", err.Error()) return err } - r.Body = ConnectIOReader(connection) + r.Body = connectIOReader(connection) } else { r.Body = ioutil.NopCloser(&bytes.Buffer{}) } diff --git a/plugin/client_rpc_generated.go b/plugin/client_rpc_generated.go index fbc9d596c..ab884e647 100644 --- a/plugin/client_rpc_generated.go +++ b/plugin/client_rpc_generated.go @@ -14,19 +14,19 @@ import ( ) func init() { - HookNameToId["OnDeactivate"] = OnDeactivateId + hookNameToId["OnDeactivate"] = OnDeactivateId } -type OnDeactivateArgs struct { +type Z_OnDeactivateArgs struct { } -type OnDeactivateReturns struct { +type Z_OnDeactivateReturns struct { A error } -func (g *HooksRPCClient) OnDeactivate() error { - _args := &OnDeactivateArgs{} - _returns := &OnDeactivateReturns{} +func (g *hooksRPCClient) OnDeactivate() error { + _args := &Z_OnDeactivateArgs{} + _returns := &Z_OnDeactivateReturns{} if g.implemented[OnDeactivateId] { if err := g.client.Call("Plugin.OnDeactivate", _args, _returns); err != nil { g.log.Error("RPC call OnDeactivate to plugin failed.", mlog.Err(err)) @@ -35,7 +35,7 @@ func (g *HooksRPCClient) OnDeactivate() error { return _returns.A } -func (s *HooksRPCServer) OnDeactivate(args *OnDeactivateArgs, returns *OnDeactivateReturns) error { +func (s *hooksRPCServer) OnDeactivate(args *Z_OnDeactivateArgs, returns *Z_OnDeactivateReturns) error { if hook, ok := s.impl.(interface { OnDeactivate() error }); ok { @@ -47,19 +47,19 @@ func (s *HooksRPCServer) OnDeactivate(args *OnDeactivateArgs, returns *OnDeactiv } func init() { - HookNameToId["OnConfigurationChange"] = OnConfigurationChangeId + hookNameToId["OnConfigurationChange"] = OnConfigurationChangeId } -type OnConfigurationChangeArgs struct { +type Z_OnConfigurationChangeArgs struct { } -type OnConfigurationChangeReturns struct { +type Z_OnConfigurationChangeReturns struct { A error } -func (g *HooksRPCClient) OnConfigurationChange() error { - _args := &OnConfigurationChangeArgs{} - _returns := &OnConfigurationChangeReturns{} +func (g *hooksRPCClient) OnConfigurationChange() error { + _args := &Z_OnConfigurationChangeArgs{} + _returns := &Z_OnConfigurationChangeReturns{} if g.implemented[OnConfigurationChangeId] { if err := g.client.Call("Plugin.OnConfigurationChange", _args, _returns); err != nil { g.log.Error("RPC call OnConfigurationChange to plugin failed.", mlog.Err(err)) @@ -68,7 +68,7 @@ func (g *HooksRPCClient) OnConfigurationChange() error { return _returns.A } -func (s *HooksRPCServer) OnConfigurationChange(args *OnConfigurationChangeArgs, returns *OnConfigurationChangeReturns) error { +func (s *hooksRPCServer) OnConfigurationChange(args *Z_OnConfigurationChangeArgs, returns *Z_OnConfigurationChangeReturns) error { if hook, ok := s.impl.(interface { OnConfigurationChange() error }); ok { @@ -80,22 +80,22 @@ func (s *HooksRPCServer) OnConfigurationChange(args *OnConfigurationChangeArgs, } func init() { - HookNameToId["ExecuteCommand"] = ExecuteCommandId + hookNameToId["ExecuteCommand"] = ExecuteCommandId } -type ExecuteCommandArgs struct { +type Z_ExecuteCommandArgs struct { A *Context B *model.CommandArgs } -type ExecuteCommandReturns struct { +type Z_ExecuteCommandReturns struct { A *model.CommandResponse B *model.AppError } -func (g *HooksRPCClient) ExecuteCommand(c *Context, args *model.CommandArgs) (*model.CommandResponse, *model.AppError) { - _args := &ExecuteCommandArgs{c, args} - _returns := &ExecuteCommandReturns{} +func (g *hooksRPCClient) ExecuteCommand(c *Context, args *model.CommandArgs) (*model.CommandResponse, *model.AppError) { + _args := &Z_ExecuteCommandArgs{c, args} + _returns := &Z_ExecuteCommandReturns{} if g.implemented[ExecuteCommandId] { if err := g.client.Call("Plugin.ExecuteCommand", _args, _returns); err != nil { g.log.Error("RPC call ExecuteCommand to plugin failed.", mlog.Err(err)) @@ -104,7 +104,7 @@ func (g *HooksRPCClient) ExecuteCommand(c *Context, args *model.CommandArgs) (*m return _returns.A, _returns.B } -func (s *HooksRPCServer) ExecuteCommand(args *ExecuteCommandArgs, returns *ExecuteCommandReturns) error { +func (s *hooksRPCServer) ExecuteCommand(args *Z_ExecuteCommandArgs, returns *Z_ExecuteCommandReturns) error { if hook, ok := s.impl.(interface { ExecuteCommand(c *Context, args *model.CommandArgs) (*model.CommandResponse, *model.AppError) }); ok { @@ -116,22 +116,22 @@ func (s *HooksRPCServer) ExecuteCommand(args *ExecuteCommandArgs, returns *Execu } func init() { - HookNameToId["MessageWillBePosted"] = MessageWillBePostedId + hookNameToId["MessageWillBePosted"] = MessageWillBePostedId } -type MessageWillBePostedArgs struct { +type Z_MessageWillBePostedArgs struct { A *Context B *model.Post } -type MessageWillBePostedReturns struct { +type Z_MessageWillBePostedReturns struct { A *model.Post B string } -func (g *HooksRPCClient) MessageWillBePosted(c *Context, post *model.Post) (*model.Post, string) { - _args := &MessageWillBePostedArgs{c, post} - _returns := &MessageWillBePostedReturns{} +func (g *hooksRPCClient) MessageWillBePosted(c *Context, post *model.Post) (*model.Post, string) { + _args := &Z_MessageWillBePostedArgs{c, post} + _returns := &Z_MessageWillBePostedReturns{} if g.implemented[MessageWillBePostedId] { if err := g.client.Call("Plugin.MessageWillBePosted", _args, _returns); err != nil { g.log.Error("RPC call MessageWillBePosted to plugin failed.", mlog.Err(err)) @@ -140,7 +140,7 @@ func (g *HooksRPCClient) MessageWillBePosted(c *Context, post *model.Post) (*mod return _returns.A, _returns.B } -func (s *HooksRPCServer) MessageWillBePosted(args *MessageWillBePostedArgs, returns *MessageWillBePostedReturns) error { +func (s *hooksRPCServer) MessageWillBePosted(args *Z_MessageWillBePostedArgs, returns *Z_MessageWillBePostedReturns) error { if hook, ok := s.impl.(interface { MessageWillBePosted(c *Context, post *model.Post) (*model.Post, string) }); ok { @@ -152,23 +152,23 @@ func (s *HooksRPCServer) MessageWillBePosted(args *MessageWillBePostedArgs, retu } func init() { - HookNameToId["MessageWillBeUpdated"] = MessageWillBeUpdatedId + hookNameToId["MessageWillBeUpdated"] = MessageWillBeUpdatedId } -type MessageWillBeUpdatedArgs struct { +type Z_MessageWillBeUpdatedArgs struct { A *Context B *model.Post C *model.Post } -type MessageWillBeUpdatedReturns struct { +type Z_MessageWillBeUpdatedReturns struct { A *model.Post B string } -func (g *HooksRPCClient) MessageWillBeUpdated(c *Context, newPost, oldPost *model.Post) (*model.Post, string) { - _args := &MessageWillBeUpdatedArgs{c, newPost, oldPost} - _returns := &MessageWillBeUpdatedReturns{} +func (g *hooksRPCClient) MessageWillBeUpdated(c *Context, newPost, oldPost *model.Post) (*model.Post, string) { + _args := &Z_MessageWillBeUpdatedArgs{c, newPost, oldPost} + _returns := &Z_MessageWillBeUpdatedReturns{} if g.implemented[MessageWillBeUpdatedId] { if err := g.client.Call("Plugin.MessageWillBeUpdated", _args, _returns); err != nil { g.log.Error("RPC call MessageWillBeUpdated to plugin failed.", mlog.Err(err)) @@ -177,7 +177,7 @@ func (g *HooksRPCClient) MessageWillBeUpdated(c *Context, newPost, oldPost *mode return _returns.A, _returns.B } -func (s *HooksRPCServer) MessageWillBeUpdated(args *MessageWillBeUpdatedArgs, returns *MessageWillBeUpdatedReturns) error { +func (s *hooksRPCServer) MessageWillBeUpdated(args *Z_MessageWillBeUpdatedArgs, returns *Z_MessageWillBeUpdatedReturns) error { if hook, ok := s.impl.(interface { MessageWillBeUpdated(c *Context, newPost, oldPost *model.Post) (*model.Post, string) }); ok { @@ -189,20 +189,20 @@ func (s *HooksRPCServer) MessageWillBeUpdated(args *MessageWillBeUpdatedArgs, re } func init() { - HookNameToId["MessageHasBeenPosted"] = MessageHasBeenPostedId + hookNameToId["MessageHasBeenPosted"] = MessageHasBeenPostedId } -type MessageHasBeenPostedArgs struct { +type Z_MessageHasBeenPostedArgs struct { A *Context B *model.Post } -type MessageHasBeenPostedReturns struct { +type Z_MessageHasBeenPostedReturns struct { } -func (g *HooksRPCClient) MessageHasBeenPosted(c *Context, post *model.Post) { - _args := &MessageHasBeenPostedArgs{c, post} - _returns := &MessageHasBeenPostedReturns{} +func (g *hooksRPCClient) MessageHasBeenPosted(c *Context, post *model.Post) { + _args := &Z_MessageHasBeenPostedArgs{c, post} + _returns := &Z_MessageHasBeenPostedReturns{} if g.implemented[MessageHasBeenPostedId] { if err := g.client.Call("Plugin.MessageHasBeenPosted", _args, _returns); err != nil { g.log.Error("RPC call MessageHasBeenPosted to plugin failed.", mlog.Err(err)) @@ -211,7 +211,7 @@ func (g *HooksRPCClient) MessageHasBeenPosted(c *Context, post *model.Post) { return } -func (s *HooksRPCServer) MessageHasBeenPosted(args *MessageHasBeenPostedArgs, returns *MessageHasBeenPostedReturns) error { +func (s *hooksRPCServer) MessageHasBeenPosted(args *Z_MessageHasBeenPostedArgs, returns *Z_MessageHasBeenPostedReturns) error { if hook, ok := s.impl.(interface { MessageHasBeenPosted(c *Context, post *model.Post) }); ok { @@ -223,21 +223,21 @@ func (s *HooksRPCServer) MessageHasBeenPosted(args *MessageHasBeenPostedArgs, re } func init() { - HookNameToId["MessageHasBeenUpdated"] = MessageHasBeenUpdatedId + hookNameToId["MessageHasBeenUpdated"] = MessageHasBeenUpdatedId } -type MessageHasBeenUpdatedArgs struct { +type Z_MessageHasBeenUpdatedArgs struct { A *Context B *model.Post C *model.Post } -type MessageHasBeenUpdatedReturns struct { +type Z_MessageHasBeenUpdatedReturns struct { } -func (g *HooksRPCClient) MessageHasBeenUpdated(c *Context, newPost, oldPost *model.Post) { - _args := &MessageHasBeenUpdatedArgs{c, newPost, oldPost} - _returns := &MessageHasBeenUpdatedReturns{} +func (g *hooksRPCClient) MessageHasBeenUpdated(c *Context, newPost, oldPost *model.Post) { + _args := &Z_MessageHasBeenUpdatedArgs{c, newPost, oldPost} + _returns := &Z_MessageHasBeenUpdatedReturns{} if g.implemented[MessageHasBeenUpdatedId] { if err := g.client.Call("Plugin.MessageHasBeenUpdated", _args, _returns); err != nil { g.log.Error("RPC call MessageHasBeenUpdated to plugin failed.", mlog.Err(err)) @@ -246,7 +246,7 @@ func (g *HooksRPCClient) MessageHasBeenUpdated(c *Context, newPost, oldPost *mod return } -func (s *HooksRPCServer) MessageHasBeenUpdated(args *MessageHasBeenUpdatedArgs, returns *MessageHasBeenUpdatedReturns) error { +func (s *hooksRPCServer) MessageHasBeenUpdated(args *Z_MessageHasBeenUpdatedArgs, returns *Z_MessageHasBeenUpdatedReturns) error { if hook, ok := s.impl.(interface { MessageHasBeenUpdated(c *Context, newPost, oldPost *model.Post) }); ok { @@ -258,20 +258,20 @@ func (s *HooksRPCServer) MessageHasBeenUpdated(args *MessageHasBeenUpdatedArgs, } func init() { - HookNameToId["ChannelHasBeenCreated"] = ChannelHasBeenCreatedId + hookNameToId["ChannelHasBeenCreated"] = ChannelHasBeenCreatedId } -type ChannelHasBeenCreatedArgs struct { +type Z_ChannelHasBeenCreatedArgs struct { A *Context B *model.Channel } -type ChannelHasBeenCreatedReturns struct { +type Z_ChannelHasBeenCreatedReturns struct { } -func (g *HooksRPCClient) ChannelHasBeenCreated(c *Context, channel *model.Channel) { - _args := &ChannelHasBeenCreatedArgs{c, channel} - _returns := &ChannelHasBeenCreatedReturns{} +func (g *hooksRPCClient) ChannelHasBeenCreated(c *Context, channel *model.Channel) { + _args := &Z_ChannelHasBeenCreatedArgs{c, channel} + _returns := &Z_ChannelHasBeenCreatedReturns{} if g.implemented[ChannelHasBeenCreatedId] { if err := g.client.Call("Plugin.ChannelHasBeenCreated", _args, _returns); err != nil { g.log.Error("RPC call ChannelHasBeenCreated to plugin failed.", mlog.Err(err)) @@ -280,7 +280,7 @@ func (g *HooksRPCClient) ChannelHasBeenCreated(c *Context, channel *model.Channe return } -func (s *HooksRPCServer) ChannelHasBeenCreated(args *ChannelHasBeenCreatedArgs, returns *ChannelHasBeenCreatedReturns) error { +func (s *hooksRPCServer) ChannelHasBeenCreated(args *Z_ChannelHasBeenCreatedArgs, returns *Z_ChannelHasBeenCreatedReturns) error { if hook, ok := s.impl.(interface { ChannelHasBeenCreated(c *Context, channel *model.Channel) }); ok { @@ -292,21 +292,21 @@ func (s *HooksRPCServer) ChannelHasBeenCreated(args *ChannelHasBeenCreatedArgs, } func init() { - HookNameToId["UserHasJoinedChannel"] = UserHasJoinedChannelId + hookNameToId["UserHasJoinedChannel"] = UserHasJoinedChannelId } -type UserHasJoinedChannelArgs struct { +type Z_UserHasJoinedChannelArgs struct { A *Context B *model.ChannelMember C *model.User } -type UserHasJoinedChannelReturns struct { +type Z_UserHasJoinedChannelReturns struct { } -func (g *HooksRPCClient) UserHasJoinedChannel(c *Context, channelMember *model.ChannelMember, actor *model.User) { - _args := &UserHasJoinedChannelArgs{c, channelMember, actor} - _returns := &UserHasJoinedChannelReturns{} +func (g *hooksRPCClient) UserHasJoinedChannel(c *Context, channelMember *model.ChannelMember, actor *model.User) { + _args := &Z_UserHasJoinedChannelArgs{c, channelMember, actor} + _returns := &Z_UserHasJoinedChannelReturns{} if g.implemented[UserHasJoinedChannelId] { if err := g.client.Call("Plugin.UserHasJoinedChannel", _args, _returns); err != nil { g.log.Error("RPC call UserHasJoinedChannel to plugin failed.", mlog.Err(err)) @@ -315,7 +315,7 @@ func (g *HooksRPCClient) UserHasJoinedChannel(c *Context, channelMember *model.C return } -func (s *HooksRPCServer) UserHasJoinedChannel(args *UserHasJoinedChannelArgs, returns *UserHasJoinedChannelReturns) error { +func (s *hooksRPCServer) UserHasJoinedChannel(args *Z_UserHasJoinedChannelArgs, returns *Z_UserHasJoinedChannelReturns) error { if hook, ok := s.impl.(interface { UserHasJoinedChannel(c *Context, channelMember *model.ChannelMember, actor *model.User) }); ok { @@ -327,21 +327,21 @@ func (s *HooksRPCServer) UserHasJoinedChannel(args *UserHasJoinedChannelArgs, re } func init() { - HookNameToId["UserHasLeftChannel"] = UserHasLeftChannelId + hookNameToId["UserHasLeftChannel"] = UserHasLeftChannelId } -type UserHasLeftChannelArgs struct { +type Z_UserHasLeftChannelArgs struct { A *Context B *model.ChannelMember C *model.User } -type UserHasLeftChannelReturns struct { +type Z_UserHasLeftChannelReturns struct { } -func (g *HooksRPCClient) UserHasLeftChannel(c *Context, channelMember *model.ChannelMember, actor *model.User) { - _args := &UserHasLeftChannelArgs{c, channelMember, actor} - _returns := &UserHasLeftChannelReturns{} +func (g *hooksRPCClient) UserHasLeftChannel(c *Context, channelMember *model.ChannelMember, actor *model.User) { + _args := &Z_UserHasLeftChannelArgs{c, channelMember, actor} + _returns := &Z_UserHasLeftChannelReturns{} if g.implemented[UserHasLeftChannelId] { if err := g.client.Call("Plugin.UserHasLeftChannel", _args, _returns); err != nil { g.log.Error("RPC call UserHasLeftChannel to plugin failed.", mlog.Err(err)) @@ -350,7 +350,7 @@ func (g *HooksRPCClient) UserHasLeftChannel(c *Context, channelMember *model.Cha return } -func (s *HooksRPCServer) UserHasLeftChannel(args *UserHasLeftChannelArgs, returns *UserHasLeftChannelReturns) error { +func (s *hooksRPCServer) UserHasLeftChannel(args *Z_UserHasLeftChannelArgs, returns *Z_UserHasLeftChannelReturns) error { if hook, ok := s.impl.(interface { UserHasLeftChannel(c *Context, channelMember *model.ChannelMember, actor *model.User) }); ok { @@ -362,21 +362,21 @@ func (s *HooksRPCServer) UserHasLeftChannel(args *UserHasLeftChannelArgs, return } func init() { - HookNameToId["UserHasJoinedTeam"] = UserHasJoinedTeamId + hookNameToId["UserHasJoinedTeam"] = UserHasJoinedTeamId } -type UserHasJoinedTeamArgs struct { +type Z_UserHasJoinedTeamArgs struct { A *Context B *model.TeamMember C *model.User } -type UserHasJoinedTeamReturns struct { +type Z_UserHasJoinedTeamReturns struct { } -func (g *HooksRPCClient) UserHasJoinedTeam(c *Context, teamMember *model.TeamMember, actor *model.User) { - _args := &UserHasJoinedTeamArgs{c, teamMember, actor} - _returns := &UserHasJoinedTeamReturns{} +func (g *hooksRPCClient) UserHasJoinedTeam(c *Context, teamMember *model.TeamMember, actor *model.User) { + _args := &Z_UserHasJoinedTeamArgs{c, teamMember, actor} + _returns := &Z_UserHasJoinedTeamReturns{} if g.implemented[UserHasJoinedTeamId] { if err := g.client.Call("Plugin.UserHasJoinedTeam", _args, _returns); err != nil { g.log.Error("RPC call UserHasJoinedTeam to plugin failed.", mlog.Err(err)) @@ -385,7 +385,7 @@ func (g *HooksRPCClient) UserHasJoinedTeam(c *Context, teamMember *model.TeamMem return } -func (s *HooksRPCServer) UserHasJoinedTeam(args *UserHasJoinedTeamArgs, returns *UserHasJoinedTeamReturns) error { +func (s *hooksRPCServer) UserHasJoinedTeam(args *Z_UserHasJoinedTeamArgs, returns *Z_UserHasJoinedTeamReturns) error { if hook, ok := s.impl.(interface { UserHasJoinedTeam(c *Context, teamMember *model.TeamMember, actor *model.User) }); ok { @@ -397,21 +397,21 @@ func (s *HooksRPCServer) UserHasJoinedTeam(args *UserHasJoinedTeamArgs, returns } func init() { - HookNameToId["UserHasLeftTeam"] = UserHasLeftTeamId + hookNameToId["UserHasLeftTeam"] = UserHasLeftTeamId } -type UserHasLeftTeamArgs struct { +type Z_UserHasLeftTeamArgs struct { A *Context B *model.TeamMember C *model.User } -type UserHasLeftTeamReturns struct { +type Z_UserHasLeftTeamReturns struct { } -func (g *HooksRPCClient) UserHasLeftTeam(c *Context, teamMember *model.TeamMember, actor *model.User) { - _args := &UserHasLeftTeamArgs{c, teamMember, actor} - _returns := &UserHasLeftTeamReturns{} +func (g *hooksRPCClient) UserHasLeftTeam(c *Context, teamMember *model.TeamMember, actor *model.User) { + _args := &Z_UserHasLeftTeamArgs{c, teamMember, actor} + _returns := &Z_UserHasLeftTeamReturns{} if g.implemented[UserHasLeftTeamId] { if err := g.client.Call("Plugin.UserHasLeftTeam", _args, _returns); err != nil { g.log.Error("RPC call UserHasLeftTeam to plugin failed.", mlog.Err(err)) @@ -420,7 +420,7 @@ func (g *HooksRPCClient) UserHasLeftTeam(c *Context, teamMember *model.TeamMembe return } -func (s *HooksRPCServer) UserHasLeftTeam(args *UserHasLeftTeamArgs, returns *UserHasLeftTeamReturns) error { +func (s *hooksRPCServer) UserHasLeftTeam(args *Z_UserHasLeftTeamArgs, returns *Z_UserHasLeftTeamReturns) error { if hook, ok := s.impl.(interface { UserHasLeftTeam(c *Context, teamMember *model.TeamMember, actor *model.User) }); ok { @@ -431,24 +431,24 @@ func (s *HooksRPCServer) UserHasLeftTeam(args *UserHasLeftTeamArgs, returns *Use return nil } -type RegisterCommandArgs struct { +type Z_RegisterCommandArgs struct { A *model.Command } -type RegisterCommandReturns struct { +type Z_RegisterCommandReturns struct { A error } -func (g *APIRPCClient) RegisterCommand(command *model.Command) error { - _args := &RegisterCommandArgs{command} - _returns := &RegisterCommandReturns{} +func (g *apiRPCClient) RegisterCommand(command *model.Command) error { + _args := &Z_RegisterCommandArgs{command} + _returns := &Z_RegisterCommandReturns{} if err := g.client.Call("Plugin.RegisterCommand", _args, _returns); err != nil { g.log.Error("RPC call to RegisterCommand API failed.", mlog.Err(err)) } return _returns.A } -func (s *APIRPCServer) RegisterCommand(args *RegisterCommandArgs, returns *RegisterCommandReturns) error { +func (s *apiRPCServer) RegisterCommand(args *Z_RegisterCommandArgs, returns *Z_RegisterCommandReturns) error { if hook, ok := s.impl.(interface { RegisterCommand(command *model.Command) error }); ok { @@ -459,25 +459,25 @@ func (s *APIRPCServer) RegisterCommand(args *RegisterCommandArgs, returns *Regis return nil } -type UnregisterCommandArgs struct { +type Z_UnregisterCommandArgs struct { A string B string } -type UnregisterCommandReturns struct { +type Z_UnregisterCommandReturns struct { A error } -func (g *APIRPCClient) UnregisterCommand(teamId, trigger string) error { - _args := &UnregisterCommandArgs{teamId, trigger} - _returns := &UnregisterCommandReturns{} +func (g *apiRPCClient) UnregisterCommand(teamId, trigger string) error { + _args := &Z_UnregisterCommandArgs{teamId, trigger} + _returns := &Z_UnregisterCommandReturns{} if err := g.client.Call("Plugin.UnregisterCommand", _args, _returns); err != nil { g.log.Error("RPC call to UnregisterCommand API failed.", mlog.Err(err)) } return _returns.A } -func (s *APIRPCServer) UnregisterCommand(args *UnregisterCommandArgs, returns *UnregisterCommandReturns) error { +func (s *apiRPCServer) UnregisterCommand(args *Z_UnregisterCommandArgs, returns *Z_UnregisterCommandReturns) error { if hook, ok := s.impl.(interface { UnregisterCommand(teamId, trigger string) error }); ok { @@ -488,23 +488,23 @@ func (s *APIRPCServer) UnregisterCommand(args *UnregisterCommandArgs, returns *U return nil } -type GetConfigArgs struct { +type Z_GetConfigArgs struct { } -type GetConfigReturns struct { +type Z_GetConfigReturns struct { A *model.Config } -func (g *APIRPCClient) GetConfig() *model.Config { - _args := &GetConfigArgs{} - _returns := &GetConfigReturns{} +func (g *apiRPCClient) GetConfig() *model.Config { + _args := &Z_GetConfigArgs{} + _returns := &Z_GetConfigReturns{} if err := g.client.Call("Plugin.GetConfig", _args, _returns); err != nil { g.log.Error("RPC call to GetConfig API failed.", mlog.Err(err)) } return _returns.A } -func (s *APIRPCServer) GetConfig(args *GetConfigArgs, returns *GetConfigReturns) error { +func (s *apiRPCServer) GetConfig(args *Z_GetConfigArgs, returns *Z_GetConfigReturns) error { if hook, ok := s.impl.(interface { GetConfig() *model.Config }); ok { @@ -515,24 +515,24 @@ func (s *APIRPCServer) GetConfig(args *GetConfigArgs, returns *GetConfigReturns) return nil } -type SaveConfigArgs struct { +type Z_SaveConfigArgs struct { A *model.Config } -type SaveConfigReturns struct { +type Z_SaveConfigReturns struct { A *model.AppError } -func (g *APIRPCClient) SaveConfig(config *model.Config) *model.AppError { - _args := &SaveConfigArgs{config} - _returns := &SaveConfigReturns{} +func (g *apiRPCClient) SaveConfig(config *model.Config) *model.AppError { + _args := &Z_SaveConfigArgs{config} + _returns := &Z_SaveConfigReturns{} if err := g.client.Call("Plugin.SaveConfig", _args, _returns); err != nil { g.log.Error("RPC call to SaveConfig API failed.", mlog.Err(err)) } return _returns.A } -func (s *APIRPCServer) SaveConfig(args *SaveConfigArgs, returns *SaveConfigReturns) error { +func (s *apiRPCServer) SaveConfig(args *Z_SaveConfigArgs, returns *Z_SaveConfigReturns) error { if hook, ok := s.impl.(interface { SaveConfig(config *model.Config) *model.AppError }); ok { @@ -543,25 +543,25 @@ func (s *APIRPCServer) SaveConfig(args *SaveConfigArgs, returns *SaveConfigRetur return nil } -type CreateUserArgs struct { +type Z_CreateUserArgs struct { A *model.User } -type CreateUserReturns struct { +type Z_CreateUserReturns struct { A *model.User B *model.AppError } -func (g *APIRPCClient) CreateUser(user *model.User) (*model.User, *model.AppError) { - _args := &CreateUserArgs{user} - _returns := &CreateUserReturns{} +func (g *apiRPCClient) CreateUser(user *model.User) (*model.User, *model.AppError) { + _args := &Z_CreateUserArgs{user} + _returns := &Z_CreateUserReturns{} if err := g.client.Call("Plugin.CreateUser", _args, _returns); err != nil { g.log.Error("RPC call to CreateUser API failed.", mlog.Err(err)) } return _returns.A, _returns.B } -func (s *APIRPCServer) CreateUser(args *CreateUserArgs, returns *CreateUserReturns) error { +func (s *apiRPCServer) CreateUser(args *Z_CreateUserArgs, returns *Z_CreateUserReturns) error { if hook, ok := s.impl.(interface { CreateUser(user *model.User) (*model.User, *model.AppError) }); ok { @@ -572,24 +572,24 @@ func (s *APIRPCServer) CreateUser(args *CreateUserArgs, returns *CreateUserRetur return nil } -type DeleteUserArgs struct { +type Z_DeleteUserArgs struct { A string } -type DeleteUserReturns struct { +type Z_DeleteUserReturns struct { A *model.AppError } -func (g *APIRPCClient) DeleteUser(userId string) *model.AppError { - _args := &DeleteUserArgs{userId} - _returns := &DeleteUserReturns{} +func (g *apiRPCClient) DeleteUser(userId string) *model.AppError { + _args := &Z_DeleteUserArgs{userId} + _returns := &Z_DeleteUserReturns{} if err := g.client.Call("Plugin.DeleteUser", _args, _returns); err != nil { g.log.Error("RPC call to DeleteUser API failed.", mlog.Err(err)) } return _returns.A } -func (s *APIRPCServer) DeleteUser(args *DeleteUserArgs, returns *DeleteUserReturns) error { +func (s *apiRPCServer) DeleteUser(args *Z_DeleteUserArgs, returns *Z_DeleteUserReturns) error { if hook, ok := s.impl.(interface { DeleteUser(userId string) *model.AppError }); ok { @@ -600,25 +600,25 @@ func (s *APIRPCServer) DeleteUser(args *DeleteUserArgs, returns *DeleteUserRetur return nil } -type GetUserArgs struct { +type Z_GetUserArgs struct { A string } -type GetUserReturns struct { +type Z_GetUserReturns struct { A *model.User B *model.AppError } -func (g *APIRPCClient) GetUser(userId string) (*model.User, *model.AppError) { - _args := &GetUserArgs{userId} - _returns := &GetUserReturns{} +func (g *apiRPCClient) GetUser(userId string) (*model.User, *model.AppError) { + _args := &Z_GetUserArgs{userId} + _returns := &Z_GetUserReturns{} if err := g.client.Call("Plugin.GetUser", _args, _returns); err != nil { g.log.Error("RPC call to GetUser API failed.", mlog.Err(err)) } return _returns.A, _returns.B } -func (s *APIRPCServer) GetUser(args *GetUserArgs, returns *GetUserReturns) error { +func (s *apiRPCServer) GetUser(args *Z_GetUserArgs, returns *Z_GetUserReturns) error { if hook, ok := s.impl.(interface { GetUser(userId string) (*model.User, *model.AppError) }); ok { @@ -629,25 +629,25 @@ func (s *APIRPCServer) GetUser(args *GetUserArgs, returns *GetUserReturns) error return nil } -type GetUserByEmailArgs struct { +type Z_GetUserByEmailArgs struct { A string } -type GetUserByEmailReturns struct { +type Z_GetUserByEmailReturns struct { A *model.User B *model.AppError } -func (g *APIRPCClient) GetUserByEmail(email string) (*model.User, *model.AppError) { - _args := &GetUserByEmailArgs{email} - _returns := &GetUserByEmailReturns{} +func (g *apiRPCClient) GetUserByEmail(email string) (*model.User, *model.AppError) { + _args := &Z_GetUserByEmailArgs{email} + _returns := &Z_GetUserByEmailReturns{} if err := g.client.Call("Plugin.GetUserByEmail", _args, _returns); err != nil { g.log.Error("RPC call to GetUserByEmail API failed.", mlog.Err(err)) } return _returns.A, _returns.B } -func (s *APIRPCServer) GetUserByEmail(args *GetUserByEmailArgs, returns *GetUserByEmailReturns) error { +func (s *apiRPCServer) GetUserByEmail(args *Z_GetUserByEmailArgs, returns *Z_GetUserByEmailReturns) error { if hook, ok := s.impl.(interface { GetUserByEmail(email string) (*model.User, *model.AppError) }); ok { @@ -658,25 +658,25 @@ func (s *APIRPCServer) GetUserByEmail(args *GetUserByEmailArgs, returns *GetUser return nil } -type GetUserByUsernameArgs struct { +type Z_GetUserByUsernameArgs struct { A string } -type GetUserByUsernameReturns struct { +type Z_GetUserByUsernameReturns struct { A *model.User B *model.AppError } -func (g *APIRPCClient) GetUserByUsername(name string) (*model.User, *model.AppError) { - _args := &GetUserByUsernameArgs{name} - _returns := &GetUserByUsernameReturns{} +func (g *apiRPCClient) GetUserByUsername(name string) (*model.User, *model.AppError) { + _args := &Z_GetUserByUsernameArgs{name} + _returns := &Z_GetUserByUsernameReturns{} if err := g.client.Call("Plugin.GetUserByUsername", _args, _returns); err != nil { g.log.Error("RPC call to GetUserByUsername API failed.", mlog.Err(err)) } return _returns.A, _returns.B } -func (s *APIRPCServer) GetUserByUsername(args *GetUserByUsernameArgs, returns *GetUserByUsernameReturns) error { +func (s *apiRPCServer) GetUserByUsername(args *Z_GetUserByUsernameArgs, returns *Z_GetUserByUsernameReturns) error { if hook, ok := s.impl.(interface { GetUserByUsername(name string) (*model.User, *model.AppError) }); ok { @@ -687,25 +687,25 @@ func (s *APIRPCServer) GetUserByUsername(args *GetUserByUsernameArgs, returns *G return nil } -type UpdateUserArgs struct { +type Z_UpdateUserArgs struct { A *model.User } -type UpdateUserReturns struct { +type Z_UpdateUserReturns struct { A *model.User B *model.AppError } -func (g *APIRPCClient) UpdateUser(user *model.User) (*model.User, *model.AppError) { - _args := &UpdateUserArgs{user} - _returns := &UpdateUserReturns{} +func (g *apiRPCClient) UpdateUser(user *model.User) (*model.User, *model.AppError) { + _args := &Z_UpdateUserArgs{user} + _returns := &Z_UpdateUserReturns{} if err := g.client.Call("Plugin.UpdateUser", _args, _returns); err != nil { g.log.Error("RPC call to UpdateUser API failed.", mlog.Err(err)) } return _returns.A, _returns.B } -func (s *APIRPCServer) UpdateUser(args *UpdateUserArgs, returns *UpdateUserReturns) error { +func (s *apiRPCServer) UpdateUser(args *Z_UpdateUserArgs, returns *Z_UpdateUserReturns) error { if hook, ok := s.impl.(interface { UpdateUser(user *model.User) (*model.User, *model.AppError) }); ok { @@ -716,25 +716,25 @@ func (s *APIRPCServer) UpdateUser(args *UpdateUserArgs, returns *UpdateUserRetur return nil } -type CreateTeamArgs struct { +type Z_CreateTeamArgs struct { A *model.Team } -type CreateTeamReturns struct { +type Z_CreateTeamReturns struct { A *model.Team B *model.AppError } -func (g *APIRPCClient) CreateTeam(team *model.Team) (*model.Team, *model.AppError) { - _args := &CreateTeamArgs{team} - _returns := &CreateTeamReturns{} +func (g *apiRPCClient) CreateTeam(team *model.Team) (*model.Team, *model.AppError) { + _args := &Z_CreateTeamArgs{team} + _returns := &Z_CreateTeamReturns{} if err := g.client.Call("Plugin.CreateTeam", _args, _returns); err != nil { g.log.Error("RPC call to CreateTeam API failed.", mlog.Err(err)) } return _returns.A, _returns.B } -func (s *APIRPCServer) CreateTeam(args *CreateTeamArgs, returns *CreateTeamReturns) error { +func (s *apiRPCServer) CreateTeam(args *Z_CreateTeamArgs, returns *Z_CreateTeamReturns) error { if hook, ok := s.impl.(interface { CreateTeam(team *model.Team) (*model.Team, *model.AppError) }); ok { @@ -745,24 +745,24 @@ func (s *APIRPCServer) CreateTeam(args *CreateTeamArgs, returns *CreateTeamRetur return nil } -type DeleteTeamArgs struct { +type Z_DeleteTeamArgs struct { A string } -type DeleteTeamReturns struct { +type Z_DeleteTeamReturns struct { A *model.AppError } -func (g *APIRPCClient) DeleteTeam(teamId string) *model.AppError { - _args := &DeleteTeamArgs{teamId} - _returns := &DeleteTeamReturns{} +func (g *apiRPCClient) DeleteTeam(teamId string) *model.AppError { + _args := &Z_DeleteTeamArgs{teamId} + _returns := &Z_DeleteTeamReturns{} if err := g.client.Call("Plugin.DeleteTeam", _args, _returns); err != nil { g.log.Error("RPC call to DeleteTeam API failed.", mlog.Err(err)) } return _returns.A } -func (s *APIRPCServer) DeleteTeam(args *DeleteTeamArgs, returns *DeleteTeamReturns) error { +func (s *apiRPCServer) DeleteTeam(args *Z_DeleteTeamArgs, returns *Z_DeleteTeamReturns) error { if hook, ok := s.impl.(interface { DeleteTeam(teamId string) *model.AppError }); ok { @@ -773,24 +773,24 @@ func (s *APIRPCServer) DeleteTeam(args *DeleteTeamArgs, returns *DeleteTeamRetur return nil } -type GetTeamsArgs struct { +type Z_GetTeamsArgs struct { } -type GetTeamsReturns struct { +type Z_GetTeamsReturns struct { A []*model.Team B *model.AppError } -func (g *APIRPCClient) GetTeams() ([]*model.Team, *model.AppError) { - _args := &GetTeamsArgs{} - _returns := &GetTeamsReturns{} +func (g *apiRPCClient) GetTeams() ([]*model.Team, *model.AppError) { + _args := &Z_GetTeamsArgs{} + _returns := &Z_GetTeamsReturns{} if err := g.client.Call("Plugin.GetTeams", _args, _returns); err != nil { g.log.Error("RPC call to GetTeams API failed.", mlog.Err(err)) } return _returns.A, _returns.B } -func (s *APIRPCServer) GetTeams(args *GetTeamsArgs, returns *GetTeamsReturns) error { +func (s *apiRPCServer) GetTeams(args *Z_GetTeamsArgs, returns *Z_GetTeamsReturns) error { if hook, ok := s.impl.(interface { GetTeams() ([]*model.Team, *model.AppError) }); ok { @@ -801,25 +801,25 @@ func (s *APIRPCServer) GetTeams(args *GetTeamsArgs, returns *GetTeamsReturns) er return nil } -type GetTeamArgs struct { +type Z_GetTeamArgs struct { A string } -type GetTeamReturns struct { +type Z_GetTeamReturns struct { A *model.Team B *model.AppError } -func (g *APIRPCClient) GetTeam(teamId string) (*model.Team, *model.AppError) { - _args := &GetTeamArgs{teamId} - _returns := &GetTeamReturns{} +func (g *apiRPCClient) GetTeam(teamId string) (*model.Team, *model.AppError) { + _args := &Z_GetTeamArgs{teamId} + _returns := &Z_GetTeamReturns{} if err := g.client.Call("Plugin.GetTeam", _args, _returns); err != nil { g.log.Error("RPC call to GetTeam API failed.", mlog.Err(err)) } return _returns.A, _returns.B } -func (s *APIRPCServer) GetTeam(args *GetTeamArgs, returns *GetTeamReturns) error { +func (s *apiRPCServer) GetTeam(args *Z_GetTeamArgs, returns *Z_GetTeamReturns) error { if hook, ok := s.impl.(interface { GetTeam(teamId string) (*model.Team, *model.AppError) }); ok { @@ -830,25 +830,25 @@ func (s *APIRPCServer) GetTeam(args *GetTeamArgs, returns *GetTeamReturns) error return nil } -type GetTeamByNameArgs struct { +type Z_GetTeamByNameArgs struct { A string } -type GetTeamByNameReturns struct { +type Z_GetTeamByNameReturns struct { A *model.Team B *model.AppError } -func (g *APIRPCClient) GetTeamByName(name string) (*model.Team, *model.AppError) { - _args := &GetTeamByNameArgs{name} - _returns := &GetTeamByNameReturns{} +func (g *apiRPCClient) GetTeamByName(name string) (*model.Team, *model.AppError) { + _args := &Z_GetTeamByNameArgs{name} + _returns := &Z_GetTeamByNameReturns{} if err := g.client.Call("Plugin.GetTeamByName", _args, _returns); err != nil { g.log.Error("RPC call to GetTeamByName API failed.", mlog.Err(err)) } return _returns.A, _returns.B } -func (s *APIRPCServer) GetTeamByName(args *GetTeamByNameArgs, returns *GetTeamByNameReturns) error { +func (s *apiRPCServer) GetTeamByName(args *Z_GetTeamByNameArgs, returns *Z_GetTeamByNameReturns) error { if hook, ok := s.impl.(interface { GetTeamByName(name string) (*model.Team, *model.AppError) }); ok { @@ -859,25 +859,25 @@ func (s *APIRPCServer) GetTeamByName(args *GetTeamByNameArgs, returns *GetTeamBy return nil } -type UpdateTeamArgs struct { +type Z_UpdateTeamArgs struct { A *model.Team } -type UpdateTeamReturns struct { +type Z_UpdateTeamReturns struct { A *model.Team B *model.AppError } -func (g *APIRPCClient) UpdateTeam(team *model.Team) (*model.Team, *model.AppError) { - _args := &UpdateTeamArgs{team} - _returns := &UpdateTeamReturns{} +func (g *apiRPCClient) UpdateTeam(team *model.Team) (*model.Team, *model.AppError) { + _args := &Z_UpdateTeamArgs{team} + _returns := &Z_UpdateTeamReturns{} if err := g.client.Call("Plugin.UpdateTeam", _args, _returns); err != nil { g.log.Error("RPC call to UpdateTeam API failed.", mlog.Err(err)) } return _returns.A, _returns.B } -func (s *APIRPCServer) UpdateTeam(args *UpdateTeamArgs, returns *UpdateTeamReturns) error { +func (s *apiRPCServer) UpdateTeam(args *Z_UpdateTeamArgs, returns *Z_UpdateTeamReturns) error { if hook, ok := s.impl.(interface { UpdateTeam(team *model.Team) (*model.Team, *model.AppError) }); ok { @@ -888,26 +888,26 @@ func (s *APIRPCServer) UpdateTeam(args *UpdateTeamArgs, returns *UpdateTeamRetur return nil } -type CreateTeamMemberArgs struct { +type Z_CreateTeamMemberArgs struct { A string B string } -type CreateTeamMemberReturns struct { +type Z_CreateTeamMemberReturns struct { A *model.TeamMember B *model.AppError } -func (g *APIRPCClient) CreateTeamMember(teamId, userId string) (*model.TeamMember, *model.AppError) { - _args := &CreateTeamMemberArgs{teamId, userId} - _returns := &CreateTeamMemberReturns{} +func (g *apiRPCClient) CreateTeamMember(teamId, userId string) (*model.TeamMember, *model.AppError) { + _args := &Z_CreateTeamMemberArgs{teamId, userId} + _returns := &Z_CreateTeamMemberReturns{} if err := g.client.Call("Plugin.CreateTeamMember", _args, _returns); err != nil { g.log.Error("RPC call to CreateTeamMember API failed.", mlog.Err(err)) } return _returns.A, _returns.B } -func (s *APIRPCServer) CreateTeamMember(args *CreateTeamMemberArgs, returns *CreateTeamMemberReturns) error { +func (s *apiRPCServer) CreateTeamMember(args *Z_CreateTeamMemberArgs, returns *Z_CreateTeamMemberReturns) error { if hook, ok := s.impl.(interface { CreateTeamMember(teamId, userId string) (*model.TeamMember, *model.AppError) }); ok { @@ -918,27 +918,27 @@ func (s *APIRPCServer) CreateTeamMember(args *CreateTeamMemberArgs, returns *Cre return nil } -type CreateTeamMembersArgs struct { +type Z_CreateTeamMembersArgs struct { A string B []string C string } -type CreateTeamMembersReturns struct { +type Z_CreateTeamMembersReturns struct { A []*model.TeamMember B *model.AppError } -func (g *APIRPCClient) CreateTeamMembers(teamId string, userIds []string, requestorId string) ([]*model.TeamMember, *model.AppError) { - _args := &CreateTeamMembersArgs{teamId, userIds, requestorId} - _returns := &CreateTeamMembersReturns{} +func (g *apiRPCClient) CreateTeamMembers(teamId string, userIds []string, requestorId string) ([]*model.TeamMember, *model.AppError) { + _args := &Z_CreateTeamMembersArgs{teamId, userIds, requestorId} + _returns := &Z_CreateTeamMembersReturns{} if err := g.client.Call("Plugin.CreateTeamMembers", _args, _returns); err != nil { g.log.Error("RPC call to CreateTeamMembers API failed.", mlog.Err(err)) } return _returns.A, _returns.B } -func (s *APIRPCServer) CreateTeamMembers(args *CreateTeamMembersArgs, returns *CreateTeamMembersReturns) error { +func (s *apiRPCServer) CreateTeamMembers(args *Z_CreateTeamMembersArgs, returns *Z_CreateTeamMembersReturns) error { if hook, ok := s.impl.(interface { CreateTeamMembers(teamId string, userIds []string, requestorId string) ([]*model.TeamMember, *model.AppError) }); ok { @@ -949,26 +949,26 @@ func (s *APIRPCServer) CreateTeamMembers(args *CreateTeamMembersArgs, returns *C return nil } -type DeleteTeamMemberArgs struct { +type Z_DeleteTeamMemberArgs struct { A string B string C string } -type DeleteTeamMemberReturns struct { +type Z_DeleteTeamMemberReturns struct { A *model.AppError } -func (g *APIRPCClient) DeleteTeamMember(teamId, userId, requestorId string) *model.AppError { - _args := &DeleteTeamMemberArgs{teamId, userId, requestorId} - _returns := &DeleteTeamMemberReturns{} +func (g *apiRPCClient) DeleteTeamMember(teamId, userId, requestorId string) *model.AppError { + _args := &Z_DeleteTeamMemberArgs{teamId, userId, requestorId} + _returns := &Z_DeleteTeamMemberReturns{} if err := g.client.Call("Plugin.DeleteTeamMember", _args, _returns); err != nil { g.log.Error("RPC call to DeleteTeamMember API failed.", mlog.Err(err)) } return _returns.A } -func (s *APIRPCServer) DeleteTeamMember(args *DeleteTeamMemberArgs, returns *DeleteTeamMemberReturns) error { +func (s *apiRPCServer) DeleteTeamMember(args *Z_DeleteTeamMemberArgs, returns *Z_DeleteTeamMemberReturns) error { if hook, ok := s.impl.(interface { DeleteTeamMember(teamId, userId, requestorId string) *model.AppError }); ok { @@ -979,27 +979,27 @@ func (s *APIRPCServer) DeleteTeamMember(args *DeleteTeamMemberArgs, returns *Del return nil } -type GetTeamMembersArgs struct { +type Z_GetTeamMembersArgs struct { A string B int C int } -type GetTeamMembersReturns struct { +type Z_GetTeamMembersReturns struct { A []*model.TeamMember B *model.AppError } -func (g *APIRPCClient) GetTeamMembers(teamId string, offset, limit int) ([]*model.TeamMember, *model.AppError) { - _args := &GetTeamMembersArgs{teamId, offset, limit} - _returns := &GetTeamMembersReturns{} +func (g *apiRPCClient) GetTeamMembers(teamId string, offset, limit int) ([]*model.TeamMember, *model.AppError) { + _args := &Z_GetTeamMembersArgs{teamId, offset, limit} + _returns := &Z_GetTeamMembersReturns{} if err := g.client.Call("Plugin.GetTeamMembers", _args, _returns); err != nil { g.log.Error("RPC call to GetTeamMembers API failed.", mlog.Err(err)) } return _returns.A, _returns.B } -func (s *APIRPCServer) GetTeamMembers(args *GetTeamMembersArgs, returns *GetTeamMembersReturns) error { +func (s *apiRPCServer) GetTeamMembers(args *Z_GetTeamMembersArgs, returns *Z_GetTeamMembersReturns) error { if hook, ok := s.impl.(interface { GetTeamMembers(teamId string, offset, limit int) ([]*model.TeamMember, *model.AppError) }); ok { @@ -1010,26 +1010,26 @@ func (s *APIRPCServer) GetTeamMembers(args *GetTeamMembersArgs, returns *GetTeam return nil } -type GetTeamMemberArgs struct { +type Z_GetTeamMemberArgs struct { A string B string } -type GetTeamMemberReturns struct { +type Z_GetTeamMemberReturns struct { A *model.TeamMember B *model.AppError } -func (g *APIRPCClient) GetTeamMember(teamId, userId string) (*model.TeamMember, *model.AppError) { - _args := &GetTeamMemberArgs{teamId, userId} - _returns := &GetTeamMemberReturns{} +func (g *apiRPCClient) GetTeamMember(teamId, userId string) (*model.TeamMember, *model.AppError) { + _args := &Z_GetTeamMemberArgs{teamId, userId} + _returns := &Z_GetTeamMemberReturns{} if err := g.client.Call("Plugin.GetTeamMember", _args, _returns); err != nil { g.log.Error("RPC call to GetTeamMember API failed.", mlog.Err(err)) } return _returns.A, _returns.B } -func (s *APIRPCServer) GetTeamMember(args *GetTeamMemberArgs, returns *GetTeamMemberReturns) error { +func (s *apiRPCServer) GetTeamMember(args *Z_GetTeamMemberArgs, returns *Z_GetTeamMemberReturns) error { if hook, ok := s.impl.(interface { GetTeamMember(teamId, userId string) (*model.TeamMember, *model.AppError) }); ok { @@ -1040,27 +1040,27 @@ func (s *APIRPCServer) GetTeamMember(args *GetTeamMemberArgs, returns *GetTeamMe return nil } -type UpdateTeamMemberRolesArgs struct { +type Z_UpdateTeamMemberRolesArgs struct { A string B string C string } -type UpdateTeamMemberRolesReturns struct { +type Z_UpdateTeamMemberRolesReturns struct { A *model.TeamMember B *model.AppError } -func (g *APIRPCClient) UpdateTeamMemberRoles(teamId, userId, newRoles string) (*model.TeamMember, *model.AppError) { - _args := &UpdateTeamMemberRolesArgs{teamId, userId, newRoles} - _returns := &UpdateTeamMemberRolesReturns{} +func (g *apiRPCClient) UpdateTeamMemberRoles(teamId, userId, newRoles string) (*model.TeamMember, *model.AppError) { + _args := &Z_UpdateTeamMemberRolesArgs{teamId, userId, newRoles} + _returns := &Z_UpdateTeamMemberRolesReturns{} if err := g.client.Call("Plugin.UpdateTeamMemberRoles", _args, _returns); err != nil { g.log.Error("RPC call to UpdateTeamMemberRoles API failed.", mlog.Err(err)) } return _returns.A, _returns.B } -func (s *APIRPCServer) UpdateTeamMemberRoles(args *UpdateTeamMemberRolesArgs, returns *UpdateTeamMemberRolesReturns) error { +func (s *apiRPCServer) UpdateTeamMemberRoles(args *Z_UpdateTeamMemberRolesArgs, returns *Z_UpdateTeamMemberRolesReturns) error { if hook, ok := s.impl.(interface { UpdateTeamMemberRoles(teamId, userId, newRoles string) (*model.TeamMember, *model.AppError) }); ok { @@ -1071,25 +1071,25 @@ func (s *APIRPCServer) UpdateTeamMemberRoles(args *UpdateTeamMemberRolesArgs, re return nil } -type CreateChannelArgs struct { +type Z_CreateChannelArgs struct { A *model.Channel } -type CreateChannelReturns struct { +type Z_CreateChannelReturns struct { A *model.Channel B *model.AppError } -func (g *APIRPCClient) CreateChannel(channel *model.Channel) (*model.Channel, *model.AppError) { - _args := &CreateChannelArgs{channel} - _returns := &CreateChannelReturns{} +func (g *apiRPCClient) CreateChannel(channel *model.Channel) (*model.Channel, *model.AppError) { + _args := &Z_CreateChannelArgs{channel} + _returns := &Z_CreateChannelReturns{} if err := g.client.Call("Plugin.CreateChannel", _args, _returns); err != nil { g.log.Error("RPC call to CreateChannel API failed.", mlog.Err(err)) } return _returns.A, _returns.B } -func (s *APIRPCServer) CreateChannel(args *CreateChannelArgs, returns *CreateChannelReturns) error { +func (s *apiRPCServer) CreateChannel(args *Z_CreateChannelArgs, returns *Z_CreateChannelReturns) error { if hook, ok := s.impl.(interface { CreateChannel(channel *model.Channel) (*model.Channel, *model.AppError) }); ok { @@ -1100,24 +1100,24 @@ func (s *APIRPCServer) CreateChannel(args *CreateChannelArgs, returns *CreateCha return nil } -type DeleteChannelArgs struct { +type Z_DeleteChannelArgs struct { A string } -type DeleteChannelReturns struct { +type Z_DeleteChannelReturns struct { A *model.AppError } -func (g *APIRPCClient) DeleteChannel(channelId string) *model.AppError { - _args := &DeleteChannelArgs{channelId} - _returns := &DeleteChannelReturns{} +func (g *apiRPCClient) DeleteChannel(channelId string) *model.AppError { + _args := &Z_DeleteChannelArgs{channelId} + _returns := &Z_DeleteChannelReturns{} if err := g.client.Call("Plugin.DeleteChannel", _args, _returns); err != nil { g.log.Error("RPC call to DeleteChannel API failed.", mlog.Err(err)) } return _returns.A } -func (s *APIRPCServer) DeleteChannel(args *DeleteChannelArgs, returns *DeleteChannelReturns) error { +func (s *apiRPCServer) DeleteChannel(args *Z_DeleteChannelArgs, returns *Z_DeleteChannelReturns) error { if hook, ok := s.impl.(interface { DeleteChannel(channelId string) *model.AppError }); ok { @@ -1128,27 +1128,27 @@ func (s *APIRPCServer) DeleteChannel(args *DeleteChannelArgs, returns *DeleteCha return nil } -type GetPublicChannelsForTeamArgs struct { +type Z_GetPublicChannelsForTeamArgs struct { A string B int C int } -type GetPublicChannelsForTeamReturns struct { +type Z_GetPublicChannelsForTeamReturns struct { A *model.ChannelList B *model.AppError } -func (g *APIRPCClient) GetPublicChannelsForTeam(teamId string, offset, limit int) (*model.ChannelList, *model.AppError) { - _args := &GetPublicChannelsForTeamArgs{teamId, offset, limit} - _returns := &GetPublicChannelsForTeamReturns{} +func (g *apiRPCClient) GetPublicChannelsForTeam(teamId string, offset, limit int) (*model.ChannelList, *model.AppError) { + _args := &Z_GetPublicChannelsForTeamArgs{teamId, offset, limit} + _returns := &Z_GetPublicChannelsForTeamReturns{} if err := g.client.Call("Plugin.GetPublicChannelsForTeam", _args, _returns); err != nil { g.log.Error("RPC call to GetPublicChannelsForTeam API failed.", mlog.Err(err)) } return _returns.A, _returns.B } -func (s *APIRPCServer) GetPublicChannelsForTeam(args *GetPublicChannelsForTeamArgs, returns *GetPublicChannelsForTeamReturns) error { +func (s *apiRPCServer) GetPublicChannelsForTeam(args *Z_GetPublicChannelsForTeamArgs, returns *Z_GetPublicChannelsForTeamReturns) error { if hook, ok := s.impl.(interface { GetPublicChannelsForTeam(teamId string, offset, limit int) (*model.ChannelList, *model.AppError) }); ok { @@ -1159,25 +1159,25 @@ func (s *APIRPCServer) GetPublicChannelsForTeam(args *GetPublicChannelsForTeamAr return nil } -type GetChannelArgs struct { +type Z_GetChannelArgs struct { A string } -type GetChannelReturns struct { +type Z_GetChannelReturns struct { A *model.Channel B *model.AppError } -func (g *APIRPCClient) GetChannel(channelId string) (*model.Channel, *model.AppError) { - _args := &GetChannelArgs{channelId} - _returns := &GetChannelReturns{} +func (g *apiRPCClient) GetChannel(channelId string) (*model.Channel, *model.AppError) { + _args := &Z_GetChannelArgs{channelId} + _returns := &Z_GetChannelReturns{} if err := g.client.Call("Plugin.GetChannel", _args, _returns); err != nil { g.log.Error("RPC call to GetChannel API failed.", mlog.Err(err)) } return _returns.A, _returns.B } -func (s *APIRPCServer) GetChannel(args *GetChannelArgs, returns *GetChannelReturns) error { +func (s *apiRPCServer) GetChannel(args *Z_GetChannelArgs, returns *Z_GetChannelReturns) error { if hook, ok := s.impl.(interface { GetChannel(channelId string) (*model.Channel, *model.AppError) }); ok { @@ -1188,26 +1188,26 @@ func (s *APIRPCServer) GetChannel(args *GetChannelArgs, returns *GetChannelRetur return nil } -type GetChannelByNameArgs struct { +type Z_GetChannelByNameArgs struct { A string B string } -type GetChannelByNameReturns struct { +type Z_GetChannelByNameReturns struct { A *model.Channel B *model.AppError } -func (g *APIRPCClient) GetChannelByName(name, teamId string) (*model.Channel, *model.AppError) { - _args := &GetChannelByNameArgs{name, teamId} - _returns := &GetChannelByNameReturns{} +func (g *apiRPCClient) GetChannelByName(name, teamId string) (*model.Channel, *model.AppError) { + _args := &Z_GetChannelByNameArgs{name, teamId} + _returns := &Z_GetChannelByNameReturns{} if err := g.client.Call("Plugin.GetChannelByName", _args, _returns); err != nil { g.log.Error("RPC call to GetChannelByName API failed.", mlog.Err(err)) } return _returns.A, _returns.B } -func (s *APIRPCServer) GetChannelByName(args *GetChannelByNameArgs, returns *GetChannelByNameReturns) error { +func (s *apiRPCServer) GetChannelByName(args *Z_GetChannelByNameArgs, returns *Z_GetChannelByNameReturns) error { if hook, ok := s.impl.(interface { GetChannelByName(name, teamId string) (*model.Channel, *model.AppError) }); ok { @@ -1218,26 +1218,26 @@ func (s *APIRPCServer) GetChannelByName(args *GetChannelByNameArgs, returns *Get return nil } -type GetDirectChannelArgs struct { +type Z_GetDirectChannelArgs struct { A string B string } -type GetDirectChannelReturns struct { +type Z_GetDirectChannelReturns struct { A *model.Channel B *model.AppError } -func (g *APIRPCClient) GetDirectChannel(userId1, userId2 string) (*model.Channel, *model.AppError) { - _args := &GetDirectChannelArgs{userId1, userId2} - _returns := &GetDirectChannelReturns{} +func (g *apiRPCClient) GetDirectChannel(userId1, userId2 string) (*model.Channel, *model.AppError) { + _args := &Z_GetDirectChannelArgs{userId1, userId2} + _returns := &Z_GetDirectChannelReturns{} if err := g.client.Call("Plugin.GetDirectChannel", _args, _returns); err != nil { g.log.Error("RPC call to GetDirectChannel API failed.", mlog.Err(err)) } return _returns.A, _returns.B } -func (s *APIRPCServer) GetDirectChannel(args *GetDirectChannelArgs, returns *GetDirectChannelReturns) error { +func (s *apiRPCServer) GetDirectChannel(args *Z_GetDirectChannelArgs, returns *Z_GetDirectChannelReturns) error { if hook, ok := s.impl.(interface { GetDirectChannel(userId1, userId2 string) (*model.Channel, *model.AppError) }); ok { @@ -1248,25 +1248,25 @@ func (s *APIRPCServer) GetDirectChannel(args *GetDirectChannelArgs, returns *Get return nil } -type GetGroupChannelArgs struct { +type Z_GetGroupChannelArgs struct { A []string } -type GetGroupChannelReturns struct { +type Z_GetGroupChannelReturns struct { A *model.Channel B *model.AppError } -func (g *APIRPCClient) GetGroupChannel(userIds []string) (*model.Channel, *model.AppError) { - _args := &GetGroupChannelArgs{userIds} - _returns := &GetGroupChannelReturns{} +func (g *apiRPCClient) GetGroupChannel(userIds []string) (*model.Channel, *model.AppError) { + _args := &Z_GetGroupChannelArgs{userIds} + _returns := &Z_GetGroupChannelReturns{} if err := g.client.Call("Plugin.GetGroupChannel", _args, _returns); err != nil { g.log.Error("RPC call to GetGroupChannel API failed.", mlog.Err(err)) } return _returns.A, _returns.B } -func (s *APIRPCServer) GetGroupChannel(args *GetGroupChannelArgs, returns *GetGroupChannelReturns) error { +func (s *apiRPCServer) GetGroupChannel(args *Z_GetGroupChannelArgs, returns *Z_GetGroupChannelReturns) error { if hook, ok := s.impl.(interface { GetGroupChannel(userIds []string) (*model.Channel, *model.AppError) }); ok { @@ -1277,25 +1277,25 @@ func (s *APIRPCServer) GetGroupChannel(args *GetGroupChannelArgs, returns *GetGr return nil } -type UpdateChannelArgs struct { +type Z_UpdateChannelArgs struct { A *model.Channel } -type UpdateChannelReturns struct { +type Z_UpdateChannelReturns struct { A *model.Channel B *model.AppError } -func (g *APIRPCClient) UpdateChannel(channel *model.Channel) (*model.Channel, *model.AppError) { - _args := &UpdateChannelArgs{channel} - _returns := &UpdateChannelReturns{} +func (g *apiRPCClient) UpdateChannel(channel *model.Channel) (*model.Channel, *model.AppError) { + _args := &Z_UpdateChannelArgs{channel} + _returns := &Z_UpdateChannelReturns{} if err := g.client.Call("Plugin.UpdateChannel", _args, _returns); err != nil { g.log.Error("RPC call to UpdateChannel API failed.", mlog.Err(err)) } return _returns.A, _returns.B } -func (s *APIRPCServer) UpdateChannel(args *UpdateChannelArgs, returns *UpdateChannelReturns) error { +func (s *apiRPCServer) UpdateChannel(args *Z_UpdateChannelArgs, returns *Z_UpdateChannelReturns) error { if hook, ok := s.impl.(interface { UpdateChannel(channel *model.Channel) (*model.Channel, *model.AppError) }); ok { @@ -1306,26 +1306,26 @@ func (s *APIRPCServer) UpdateChannel(args *UpdateChannelArgs, returns *UpdateCha return nil } -type AddChannelMemberArgs struct { +type Z_AddChannelMemberArgs struct { A string B string } -type AddChannelMemberReturns struct { +type Z_AddChannelMemberReturns struct { A *model.ChannelMember B *model.AppError } -func (g *APIRPCClient) AddChannelMember(channelId, userId string) (*model.ChannelMember, *model.AppError) { - _args := &AddChannelMemberArgs{channelId, userId} - _returns := &AddChannelMemberReturns{} +func (g *apiRPCClient) AddChannelMember(channelId, userId string) (*model.ChannelMember, *model.AppError) { + _args := &Z_AddChannelMemberArgs{channelId, userId} + _returns := &Z_AddChannelMemberReturns{} if err := g.client.Call("Plugin.AddChannelMember", _args, _returns); err != nil { g.log.Error("RPC call to AddChannelMember API failed.", mlog.Err(err)) } return _returns.A, _returns.B } -func (s *APIRPCServer) AddChannelMember(args *AddChannelMemberArgs, returns *AddChannelMemberReturns) error { +func (s *apiRPCServer) AddChannelMember(args *Z_AddChannelMemberArgs, returns *Z_AddChannelMemberReturns) error { if hook, ok := s.impl.(interface { AddChannelMember(channelId, userId string) (*model.ChannelMember, *model.AppError) }); ok { @@ -1336,26 +1336,26 @@ func (s *APIRPCServer) AddChannelMember(args *AddChannelMemberArgs, returns *Add return nil } -type GetChannelMemberArgs struct { +type Z_GetChannelMemberArgs struct { A string B string } -type GetChannelMemberReturns struct { +type Z_GetChannelMemberReturns struct { A *model.ChannelMember B *model.AppError } -func (g *APIRPCClient) GetChannelMember(channelId, userId string) (*model.ChannelMember, *model.AppError) { - _args := &GetChannelMemberArgs{channelId, userId} - _returns := &GetChannelMemberReturns{} +func (g *apiRPCClient) GetChannelMember(channelId, userId string) (*model.ChannelMember, *model.AppError) { + _args := &Z_GetChannelMemberArgs{channelId, userId} + _returns := &Z_GetChannelMemberReturns{} if err := g.client.Call("Plugin.GetChannelMember", _args, _returns); err != nil { g.log.Error("RPC call to GetChannelMember API failed.", mlog.Err(err)) } return _returns.A, _returns.B } -func (s *APIRPCServer) GetChannelMember(args *GetChannelMemberArgs, returns *GetChannelMemberReturns) error { +func (s *apiRPCServer) GetChannelMember(args *Z_GetChannelMemberArgs, returns *Z_GetChannelMemberReturns) error { if hook, ok := s.impl.(interface { GetChannelMember(channelId, userId string) (*model.ChannelMember, *model.AppError) }); ok { @@ -1366,27 +1366,27 @@ func (s *APIRPCServer) GetChannelMember(args *GetChannelMemberArgs, returns *Get return nil } -type UpdateChannelMemberRolesArgs struct { +type Z_UpdateChannelMemberRolesArgs struct { A string B string C string } -type UpdateChannelMemberRolesReturns struct { +type Z_UpdateChannelMemberRolesReturns struct { A *model.ChannelMember B *model.AppError } -func (g *APIRPCClient) UpdateChannelMemberRoles(channelId, userId, newRoles string) (*model.ChannelMember, *model.AppError) { - _args := &UpdateChannelMemberRolesArgs{channelId, userId, newRoles} - _returns := &UpdateChannelMemberRolesReturns{} +func (g *apiRPCClient) UpdateChannelMemberRoles(channelId, userId, newRoles string) (*model.ChannelMember, *model.AppError) { + _args := &Z_UpdateChannelMemberRolesArgs{channelId, userId, newRoles} + _returns := &Z_UpdateChannelMemberRolesReturns{} if err := g.client.Call("Plugin.UpdateChannelMemberRoles", _args, _returns); err != nil { g.log.Error("RPC call to UpdateChannelMemberRoles API failed.", mlog.Err(err)) } return _returns.A, _returns.B } -func (s *APIRPCServer) UpdateChannelMemberRoles(args *UpdateChannelMemberRolesArgs, returns *UpdateChannelMemberRolesReturns) error { +func (s *apiRPCServer) UpdateChannelMemberRoles(args *Z_UpdateChannelMemberRolesArgs, returns *Z_UpdateChannelMemberRolesReturns) error { if hook, ok := s.impl.(interface { UpdateChannelMemberRoles(channelId, userId, newRoles string) (*model.ChannelMember, *model.AppError) }); ok { @@ -1397,27 +1397,27 @@ func (s *APIRPCServer) UpdateChannelMemberRoles(args *UpdateChannelMemberRolesAr return nil } -type UpdateChannelMemberNotificationsArgs struct { +type Z_UpdateChannelMemberNotificationsArgs struct { A string B string C map[string]string } -type UpdateChannelMemberNotificationsReturns struct { +type Z_UpdateChannelMemberNotificationsReturns struct { A *model.ChannelMember B *model.AppError } -func (g *APIRPCClient) UpdateChannelMemberNotifications(channelId, userId string, notifications map[string]string) (*model.ChannelMember, *model.AppError) { - _args := &UpdateChannelMemberNotificationsArgs{channelId, userId, notifications} - _returns := &UpdateChannelMemberNotificationsReturns{} +func (g *apiRPCClient) UpdateChannelMemberNotifications(channelId, userId string, notifications map[string]string) (*model.ChannelMember, *model.AppError) { + _args := &Z_UpdateChannelMemberNotificationsArgs{channelId, userId, notifications} + _returns := &Z_UpdateChannelMemberNotificationsReturns{} if err := g.client.Call("Plugin.UpdateChannelMemberNotifications", _args, _returns); err != nil { g.log.Error("RPC call to UpdateChannelMemberNotifications API failed.", mlog.Err(err)) } return _returns.A, _returns.B } -func (s *APIRPCServer) UpdateChannelMemberNotifications(args *UpdateChannelMemberNotificationsArgs, returns *UpdateChannelMemberNotificationsReturns) error { +func (s *apiRPCServer) UpdateChannelMemberNotifications(args *Z_UpdateChannelMemberNotificationsArgs, returns *Z_UpdateChannelMemberNotificationsReturns) error { if hook, ok := s.impl.(interface { UpdateChannelMemberNotifications(channelId, userId string, notifications map[string]string) (*model.ChannelMember, *model.AppError) }); ok { @@ -1428,25 +1428,25 @@ func (s *APIRPCServer) UpdateChannelMemberNotifications(args *UpdateChannelMembe return nil } -type DeleteChannelMemberArgs struct { +type Z_DeleteChannelMemberArgs struct { A string B string } -type DeleteChannelMemberReturns struct { +type Z_DeleteChannelMemberReturns struct { A *model.AppError } -func (g *APIRPCClient) DeleteChannelMember(channelId, userId string) *model.AppError { - _args := &DeleteChannelMemberArgs{channelId, userId} - _returns := &DeleteChannelMemberReturns{} +func (g *apiRPCClient) DeleteChannelMember(channelId, userId string) *model.AppError { + _args := &Z_DeleteChannelMemberArgs{channelId, userId} + _returns := &Z_DeleteChannelMemberReturns{} if err := g.client.Call("Plugin.DeleteChannelMember", _args, _returns); err != nil { g.log.Error("RPC call to DeleteChannelMember API failed.", mlog.Err(err)) } return _returns.A } -func (s *APIRPCServer) DeleteChannelMember(args *DeleteChannelMemberArgs, returns *DeleteChannelMemberReturns) error { +func (s *apiRPCServer) DeleteChannelMember(args *Z_DeleteChannelMemberArgs, returns *Z_DeleteChannelMemberReturns) error { if hook, ok := s.impl.(interface { DeleteChannelMember(channelId, userId string) *model.AppError }); ok { @@ -1457,25 +1457,25 @@ func (s *APIRPCServer) DeleteChannelMember(args *DeleteChannelMemberArgs, return return nil } -type CreatePostArgs struct { +type Z_CreatePostArgs struct { A *model.Post } -type CreatePostReturns struct { +type Z_CreatePostReturns struct { A *model.Post B *model.AppError } -func (g *APIRPCClient) CreatePost(post *model.Post) (*model.Post, *model.AppError) { - _args := &CreatePostArgs{post} - _returns := &CreatePostReturns{} +func (g *apiRPCClient) CreatePost(post *model.Post) (*model.Post, *model.AppError) { + _args := &Z_CreatePostArgs{post} + _returns := &Z_CreatePostReturns{} if err := g.client.Call("Plugin.CreatePost", _args, _returns); err != nil { g.log.Error("RPC call to CreatePost API failed.", mlog.Err(err)) } return _returns.A, _returns.B } -func (s *APIRPCServer) CreatePost(args *CreatePostArgs, returns *CreatePostReturns) error { +func (s *apiRPCServer) CreatePost(args *Z_CreatePostArgs, returns *Z_CreatePostReturns) error { if hook, ok := s.impl.(interface { CreatePost(post *model.Post) (*model.Post, *model.AppError) }); ok { @@ -1486,25 +1486,25 @@ func (s *APIRPCServer) CreatePost(args *CreatePostArgs, returns *CreatePostRetur return nil } -type SendEphemeralPostArgs struct { +type Z_SendEphemeralPostArgs struct { A string B *model.Post } -type SendEphemeralPostReturns struct { +type Z_SendEphemeralPostReturns struct { A *model.Post } -func (g *APIRPCClient) SendEphemeralPost(userId string, post *model.Post) *model.Post { - _args := &SendEphemeralPostArgs{userId, post} - _returns := &SendEphemeralPostReturns{} +func (g *apiRPCClient) SendEphemeralPost(userId string, post *model.Post) *model.Post { + _args := &Z_SendEphemeralPostArgs{userId, post} + _returns := &Z_SendEphemeralPostReturns{} if err := g.client.Call("Plugin.SendEphemeralPost", _args, _returns); err != nil { g.log.Error("RPC call to SendEphemeralPost API failed.", mlog.Err(err)) } return _returns.A } -func (s *APIRPCServer) SendEphemeralPost(args *SendEphemeralPostArgs, returns *SendEphemeralPostReturns) error { +func (s *apiRPCServer) SendEphemeralPost(args *Z_SendEphemeralPostArgs, returns *Z_SendEphemeralPostReturns) error { if hook, ok := s.impl.(interface { SendEphemeralPost(userId string, post *model.Post) *model.Post }); ok { @@ -1515,24 +1515,24 @@ func (s *APIRPCServer) SendEphemeralPost(args *SendEphemeralPostArgs, returns *S return nil } -type DeletePostArgs struct { +type Z_DeletePostArgs struct { A string } -type DeletePostReturns struct { +type Z_DeletePostReturns struct { A *model.AppError } -func (g *APIRPCClient) DeletePost(postId string) *model.AppError { - _args := &DeletePostArgs{postId} - _returns := &DeletePostReturns{} +func (g *apiRPCClient) DeletePost(postId string) *model.AppError { + _args := &Z_DeletePostArgs{postId} + _returns := &Z_DeletePostReturns{} if err := g.client.Call("Plugin.DeletePost", _args, _returns); err != nil { g.log.Error("RPC call to DeletePost API failed.", mlog.Err(err)) } return _returns.A } -func (s *APIRPCServer) DeletePost(args *DeletePostArgs, returns *DeletePostReturns) error { +func (s *apiRPCServer) DeletePost(args *Z_DeletePostArgs, returns *Z_DeletePostReturns) error { if hook, ok := s.impl.(interface { DeletePost(postId string) *model.AppError }); ok { @@ -1543,25 +1543,25 @@ func (s *APIRPCServer) DeletePost(args *DeletePostArgs, returns *DeletePostRetur return nil } -type GetPostArgs struct { +type Z_GetPostArgs struct { A string } -type GetPostReturns struct { +type Z_GetPostReturns struct { A *model.Post B *model.AppError } -func (g *APIRPCClient) GetPost(postId string) (*model.Post, *model.AppError) { - _args := &GetPostArgs{postId} - _returns := &GetPostReturns{} +func (g *apiRPCClient) GetPost(postId string) (*model.Post, *model.AppError) { + _args := &Z_GetPostArgs{postId} + _returns := &Z_GetPostReturns{} if err := g.client.Call("Plugin.GetPost", _args, _returns); err != nil { g.log.Error("RPC call to GetPost API failed.", mlog.Err(err)) } return _returns.A, _returns.B } -func (s *APIRPCServer) GetPost(args *GetPostArgs, returns *GetPostReturns) error { +func (s *apiRPCServer) GetPost(args *Z_GetPostArgs, returns *Z_GetPostReturns) error { if hook, ok := s.impl.(interface { GetPost(postId string) (*model.Post, *model.AppError) }); ok { @@ -1572,25 +1572,25 @@ func (s *APIRPCServer) GetPost(args *GetPostArgs, returns *GetPostReturns) error return nil } -type UpdatePostArgs struct { +type Z_UpdatePostArgs struct { A *model.Post } -type UpdatePostReturns struct { +type Z_UpdatePostReturns struct { A *model.Post B *model.AppError } -func (g *APIRPCClient) UpdatePost(post *model.Post) (*model.Post, *model.AppError) { - _args := &UpdatePostArgs{post} - _returns := &UpdatePostReturns{} +func (g *apiRPCClient) UpdatePost(post *model.Post) (*model.Post, *model.AppError) { + _args := &Z_UpdatePostArgs{post} + _returns := &Z_UpdatePostReturns{} if err := g.client.Call("Plugin.UpdatePost", _args, _returns); err != nil { g.log.Error("RPC call to UpdatePost API failed.", mlog.Err(err)) } return _returns.A, _returns.B } -func (s *APIRPCServer) UpdatePost(args *UpdatePostArgs, returns *UpdatePostReturns) error { +func (s *apiRPCServer) UpdatePost(args *Z_UpdatePostArgs, returns *Z_UpdatePostReturns) error { if hook, ok := s.impl.(interface { UpdatePost(post *model.Post) (*model.Post, *model.AppError) }); ok { @@ -1601,25 +1601,25 @@ func (s *APIRPCServer) UpdatePost(args *UpdatePostArgs, returns *UpdatePostRetur return nil } -type KVSetArgs struct { +type Z_KVSetArgs struct { A string B []byte } -type KVSetReturns struct { +type Z_KVSetReturns struct { A *model.AppError } -func (g *APIRPCClient) KVSet(key string, value []byte) *model.AppError { - _args := &KVSetArgs{key, value} - _returns := &KVSetReturns{} +func (g *apiRPCClient) KVSet(key string, value []byte) *model.AppError { + _args := &Z_KVSetArgs{key, value} + _returns := &Z_KVSetReturns{} if err := g.client.Call("Plugin.KVSet", _args, _returns); err != nil { g.log.Error("RPC call to KVSet API failed.", mlog.Err(err)) } return _returns.A } -func (s *APIRPCServer) KVSet(args *KVSetArgs, returns *KVSetReturns) error { +func (s *apiRPCServer) KVSet(args *Z_KVSetArgs, returns *Z_KVSetReturns) error { if hook, ok := s.impl.(interface { KVSet(key string, value []byte) *model.AppError }); ok { @@ -1630,25 +1630,25 @@ func (s *APIRPCServer) KVSet(args *KVSetArgs, returns *KVSetReturns) error { return nil } -type KVGetArgs struct { +type Z_KVGetArgs struct { A string } -type KVGetReturns struct { +type Z_KVGetReturns struct { A []byte B *model.AppError } -func (g *APIRPCClient) KVGet(key string) ([]byte, *model.AppError) { - _args := &KVGetArgs{key} - _returns := &KVGetReturns{} +func (g *apiRPCClient) KVGet(key string) ([]byte, *model.AppError) { + _args := &Z_KVGetArgs{key} + _returns := &Z_KVGetReturns{} if err := g.client.Call("Plugin.KVGet", _args, _returns); err != nil { g.log.Error("RPC call to KVGet API failed.", mlog.Err(err)) } return _returns.A, _returns.B } -func (s *APIRPCServer) KVGet(args *KVGetArgs, returns *KVGetReturns) error { +func (s *apiRPCServer) KVGet(args *Z_KVGetArgs, returns *Z_KVGetReturns) error { if hook, ok := s.impl.(interface { KVGet(key string) ([]byte, *model.AppError) }); ok { @@ -1659,24 +1659,24 @@ func (s *APIRPCServer) KVGet(args *KVGetArgs, returns *KVGetReturns) error { return nil } -type KVDeleteArgs struct { +type Z_KVDeleteArgs struct { A string } -type KVDeleteReturns struct { +type Z_KVDeleteReturns struct { A *model.AppError } -func (g *APIRPCClient) KVDelete(key string) *model.AppError { - _args := &KVDeleteArgs{key} - _returns := &KVDeleteReturns{} +func (g *apiRPCClient) KVDelete(key string) *model.AppError { + _args := &Z_KVDeleteArgs{key} + _returns := &Z_KVDeleteReturns{} if err := g.client.Call("Plugin.KVDelete", _args, _returns); err != nil { g.log.Error("RPC call to KVDelete API failed.", mlog.Err(err)) } return _returns.A } -func (s *APIRPCServer) KVDelete(args *KVDeleteArgs, returns *KVDeleteReturns) error { +func (s *apiRPCServer) KVDelete(args *Z_KVDeleteArgs, returns *Z_KVDeleteReturns) error { if hook, ok := s.impl.(interface { KVDelete(key string) *model.AppError }); ok { @@ -1687,25 +1687,25 @@ func (s *APIRPCServer) KVDelete(args *KVDeleteArgs, returns *KVDeleteReturns) er return nil } -type PublishWebSocketEventArgs struct { +type Z_PublishWebSocketEventArgs struct { A string B map[string]interface{} C *model.WebsocketBroadcast } -type PublishWebSocketEventReturns struct { +type Z_PublishWebSocketEventReturns struct { } -func (g *APIRPCClient) PublishWebSocketEvent(event string, payload map[string]interface{}, broadcast *model.WebsocketBroadcast) { - _args := &PublishWebSocketEventArgs{event, payload, broadcast} - _returns := &PublishWebSocketEventReturns{} +func (g *apiRPCClient) PublishWebSocketEvent(event string, payload map[string]interface{}, broadcast *model.WebsocketBroadcast) { + _args := &Z_PublishWebSocketEventArgs{event, payload, broadcast} + _returns := &Z_PublishWebSocketEventReturns{} if err := g.client.Call("Plugin.PublishWebSocketEvent", _args, _returns); err != nil { g.log.Error("RPC call to PublishWebSocketEvent API failed.", mlog.Err(err)) } return } -func (s *APIRPCServer) PublishWebSocketEvent(args *PublishWebSocketEventArgs, returns *PublishWebSocketEventReturns) error { +func (s *apiRPCServer) PublishWebSocketEvent(args *Z_PublishWebSocketEventArgs, returns *Z_PublishWebSocketEventReturns) error { if hook, ok := s.impl.(interface { PublishWebSocketEvent(event string, payload map[string]interface{}, broadcast *model.WebsocketBroadcast) }); ok { @@ -1716,24 +1716,24 @@ func (s *APIRPCServer) PublishWebSocketEvent(args *PublishWebSocketEventArgs, re return nil } -type LogDebugArgs struct { +type Z_LogDebugArgs struct { A string B []interface{} } -type LogDebugReturns struct { +type Z_LogDebugReturns struct { } -func (g *APIRPCClient) LogDebug(msg string, keyValuePairs ...interface{}) { - _args := &LogDebugArgs{msg, keyValuePairs} - _returns := &LogDebugReturns{} +func (g *apiRPCClient) LogDebug(msg string, keyValuePairs ...interface{}) { + _args := &Z_LogDebugArgs{msg, keyValuePairs} + _returns := &Z_LogDebugReturns{} if err := g.client.Call("Plugin.LogDebug", _args, _returns); err != nil { g.log.Error("RPC call to LogDebug API failed.", mlog.Err(err)) } return } -func (s *APIRPCServer) LogDebug(args *LogDebugArgs, returns *LogDebugReturns) error { +func (s *apiRPCServer) LogDebug(args *Z_LogDebugArgs, returns *Z_LogDebugReturns) error { if hook, ok := s.impl.(interface { LogDebug(msg string, keyValuePairs ...interface{}) }); ok { @@ -1744,24 +1744,24 @@ func (s *APIRPCServer) LogDebug(args *LogDebugArgs, returns *LogDebugReturns) er return nil } -type LogInfoArgs struct { +type Z_LogInfoArgs struct { A string B []interface{} } -type LogInfoReturns struct { +type Z_LogInfoReturns struct { } -func (g *APIRPCClient) LogInfo(msg string, keyValuePairs ...interface{}) { - _args := &LogInfoArgs{msg, keyValuePairs} - _returns := &LogInfoReturns{} +func (g *apiRPCClient) LogInfo(msg string, keyValuePairs ...interface{}) { + _args := &Z_LogInfoArgs{msg, keyValuePairs} + _returns := &Z_LogInfoReturns{} if err := g.client.Call("Plugin.LogInfo", _args, _returns); err != nil { g.log.Error("RPC call to LogInfo API failed.", mlog.Err(err)) } return } -func (s *APIRPCServer) LogInfo(args *LogInfoArgs, returns *LogInfoReturns) error { +func (s *apiRPCServer) LogInfo(args *Z_LogInfoArgs, returns *Z_LogInfoReturns) error { if hook, ok := s.impl.(interface { LogInfo(msg string, keyValuePairs ...interface{}) }); ok { @@ -1772,24 +1772,24 @@ func (s *APIRPCServer) LogInfo(args *LogInfoArgs, returns *LogInfoReturns) error return nil } -type LogErrorArgs struct { +type Z_LogErrorArgs struct { A string B []interface{} } -type LogErrorReturns struct { +type Z_LogErrorReturns struct { } -func (g *APIRPCClient) LogError(msg string, keyValuePairs ...interface{}) { - _args := &LogErrorArgs{msg, keyValuePairs} - _returns := &LogErrorReturns{} +func (g *apiRPCClient) LogError(msg string, keyValuePairs ...interface{}) { + _args := &Z_LogErrorArgs{msg, keyValuePairs} + _returns := &Z_LogErrorReturns{} if err := g.client.Call("Plugin.LogError", _args, _returns); err != nil { g.log.Error("RPC call to LogError API failed.", mlog.Err(err)) } return } -func (s *APIRPCServer) LogError(args *LogErrorArgs, returns *LogErrorReturns) error { +func (s *apiRPCServer) LogError(args *Z_LogErrorArgs, returns *Z_LogErrorReturns) error { if hook, ok := s.impl.(interface { LogError(msg string, keyValuePairs ...interface{}) }); ok { @@ -1800,24 +1800,24 @@ func (s *APIRPCServer) LogError(args *LogErrorArgs, returns *LogErrorReturns) er return nil } -type LogWarnArgs struct { +type Z_LogWarnArgs struct { A string B []interface{} } -type LogWarnReturns struct { +type Z_LogWarnReturns struct { } -func (g *APIRPCClient) LogWarn(msg string, keyValuePairs ...interface{}) { - _args := &LogWarnArgs{msg, keyValuePairs} - _returns := &LogWarnReturns{} +func (g *apiRPCClient) LogWarn(msg string, keyValuePairs ...interface{}) { + _args := &Z_LogWarnArgs{msg, keyValuePairs} + _returns := &Z_LogWarnReturns{} if err := g.client.Call("Plugin.LogWarn", _args, _returns); err != nil { g.log.Error("RPC call to LogWarn API failed.", mlog.Err(err)) } return } -func (s *APIRPCServer) LogWarn(args *LogWarnArgs, returns *LogWarnReturns) error { +func (s *apiRPCServer) LogWarn(args *Z_LogWarnArgs, returns *Z_LogWarnReturns) error { if hook, ok := s.impl.(interface { LogWarn(msg string, keyValuePairs ...interface{}) }); ok { diff --git a/plugin/context.go b/plugin/context.go new file mode 100644 index 000000000..60d01bbe4 --- /dev/null +++ b/plugin/context.go @@ -0,0 +1,10 @@ +// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved. +// See LICENSE.txt for license information. + +package plugin + +// Context passes through metadata about the request or hook event. +// +// It is currently a placeholder while the implementation details are sorted out. +type Context struct { +} diff --git a/plugin/doc.go b/plugin/doc.go new file mode 100644 index 000000000..b6806365b --- /dev/null +++ b/plugin/doc.go @@ -0,0 +1,9 @@ +// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved. +// See LICENSE.txt for license information. + +// The plugin package is used by Mattermost server plugins written in go. It also enables the +// Mattermost server to manage and interact with the running plugin environment. +// +// Note that this package exports a large number of types prefixed with Z_. These are public only +// to allow their use with Hashicorp's go-plugin (and net/rpc). Do not use these directly. +package plugin diff --git a/plugin/environment.go b/plugin/environment.go index de67225d2..450078893 100644 --- a/plugin/environment.go +++ b/plugin/environment.go @@ -14,31 +14,37 @@ import ( "github.com/pkg/errors" ) -type APIImplCreatorFunc func(*model.Manifest) API -type SupervisorCreatorFunc func(*model.BundleInfo, *mlog.Logger, API) (*Supervisor, error) +type apiImplCreatorFunc func(*model.Manifest) API +type supervisorCreatorFunc func(*model.BundleInfo, *mlog.Logger, API) (*supervisor, error) -// Hooks will be the hooks API for the plugin -// Return value should be true if we should continue calling more plugins -type MultliPluginHookRunnerFunc func(hooks Hooks) bool +// multiPluginHookRunnerFunc is a callback function to invoke as part of RunMultiPluginHook. +// +// Return false to stop the hook from iterating to subsequent plugins. +type multiPluginHookRunnerFunc func(hooks Hooks) bool -type ActivePlugin struct { +type activePlugin struct { BundleInfo *model.BundleInfo State int - Supervisor *Supervisor + + supervisor *supervisor } +// Environment represents the execution environment of active plugins. +// +// It is meant for use by the Mattermost server to manipulate, interact with and report on the set +// of active plugins. type Environment struct { - activePlugins map[string]ActivePlugin + activePlugins map[string]activePlugin mutex sync.RWMutex logger *mlog.Logger - newAPIImpl APIImplCreatorFunc + newAPIImpl apiImplCreatorFunc pluginDir string webappPluginDir string } -func NewEnvironment(newAPIImpl APIImplCreatorFunc, pluginDir string, webappPluginDir string, logger *mlog.Logger) (*Environment, error) { +func NewEnvironment(newAPIImpl apiImplCreatorFunc, pluginDir string, webappPluginDir string, logger *mlog.Logger) (*Environment, error) { return &Environment{ - activePlugins: make(map[string]ActivePlugin), + activePlugins: make(map[string]activePlugin), logger: logger, newAPIImpl: newAPIImpl, pluginDir: pluginDir, @@ -53,7 +59,7 @@ func NewEnvironment(newAPIImpl APIImplCreatorFunc, pluginDir string, webappPlugi // parsed). // // Plugins are found non-recursively and paths beginning with a dot are always ignored. -func ScanSearchPath(path string) ([]*model.BundleInfo, error) { +func scanSearchPath(path string) ([]*model.BundleInfo, error) { files, err := ioutil.ReadDir(path) if err != nil { return nil, err @@ -72,7 +78,7 @@ func ScanSearchPath(path string) ([]*model.BundleInfo, error) { // Returns a list of all plugins within the environment. func (env *Environment) Available() ([]*model.BundleInfo, error) { - return ScanSearchPath(env.pluginDir) + return scanSearchPath(env.pluginDir) } // Returns a list of all currently active plugins within the environment. @@ -88,12 +94,13 @@ func (env *Environment) Active() []*model.BundleInfo { return activePlugins } +// IsActive returns true if the plugin with the given id is active. func (env *Environment) IsActive(id string) bool { _, ok := env.activePlugins[id] return ok } -// Returns a list of plugin statuses reprensenting the state of every plugin +// Statuses returns a list of plugin statuses representing the state of every plugin func (env *Environment) Statuses() (model.PluginStatuses, error) { env.mutex.RLock() defer env.mutex.RUnlock() @@ -130,6 +137,7 @@ func (env *Environment) Statuses() (model.PluginStatuses, error) { return pluginStatuses, nil } +// Activate activates the plugin with the given id. func (env *Environment) Activate(id string) (reterr error) { env.mutex.Lock() defer env.mutex.Unlock() @@ -156,7 +164,7 @@ func (env *Environment) Activate(id string) (reterr error) { return fmt.Errorf("plugin not found: %v", id) } - activePlugin := ActivePlugin{BundleInfo: pluginInfo} + activePlugin := activePlugin{BundleInfo: pluginInfo} defer func() { if reterr == nil { activePlugin.State = model.PluginStateRunning @@ -185,11 +193,11 @@ func (env *Environment) Activate(id string) (reterr error) { } if pluginInfo.Manifest.Backend != nil { - supervisor, err := NewSupervisor(pluginInfo, env.logger, env.newAPIImpl(pluginInfo.Manifest)) + supervisor, err := newSupervisor(pluginInfo, env.logger, env.newAPIImpl(pluginInfo.Manifest)) if err != nil { return errors.Wrapf(err, "unable to start plugin: %v", id) } - activePlugin.Supervisor = supervisor + activePlugin.supervisor = supervisor } return nil @@ -204,56 +212,59 @@ func (env *Environment) Deactivate(id string) { return } else { delete(env.activePlugins, id) - if activePlugin.Supervisor != nil { - if err := activePlugin.Supervisor.Hooks().OnDeactivate(); err != nil { + if activePlugin.supervisor != nil { + if err := activePlugin.supervisor.Hooks().OnDeactivate(); err != nil { env.logger.Error("Plugin OnDeactivate() error", mlog.String("plugin_id", activePlugin.BundleInfo.Manifest.Id), mlog.Err(err)) } - activePlugin.Supervisor.Shutdown() + activePlugin.supervisor.Shutdown() } } } -// Deactivates all plugins and gracefully shuts down the environment. +// Shutdown deactivates all plugins and gracefully shuts down the environment. func (env *Environment) Shutdown() { env.mutex.Lock() defer env.mutex.Unlock() for _, activePlugin := range env.activePlugins { - if activePlugin.Supervisor != nil { - if err := activePlugin.Supervisor.Hooks().OnDeactivate(); err != nil { + if activePlugin.supervisor != nil { + if err := activePlugin.supervisor.Hooks().OnDeactivate(); err != nil { env.logger.Error("Plugin OnDeactivate() error", mlog.String("plugin_id", activePlugin.BundleInfo.Manifest.Id), mlog.Err(err)) } - activePlugin.Supervisor.Shutdown() + activePlugin.supervisor.Shutdown() } } - env.activePlugins = make(map[string]ActivePlugin) + env.activePlugins = make(map[string]activePlugin) return } -// Returns the hooks API for the plugin ID specified -// You should probably use RunMultiPluginHook instead. +// HooksForPlugin returns the hooks API for the plugin with the given id. +// +// Consider using RunMultiPluginHook instead. func (env *Environment) HooksForPlugin(id string) (Hooks, error) { env.mutex.RLock() defer env.mutex.RUnlock() - if plug, ok := env.activePlugins[id]; ok && plug.Supervisor != nil { - return plug.Supervisor.Hooks(), nil + if plug, ok := env.activePlugins[id]; ok && plug.supervisor != nil { + return plug.supervisor.Hooks(), nil } return nil, fmt.Errorf("plugin not found: %v", id) } -// Calls hookRunnerFunc with the hooks for each active plugin that implments the given HookId -// If hookRunnerFunc returns false, then iteration will not continue. -func (env *Environment) RunMultiPluginHook(hookRunnerFunc MultliPluginHookRunnerFunc, mustImplement int) { +// RunMultiPluginHook invokes hookRunnerFunc for each plugin that implements the given hookId. +// +// If hookRunnerFunc returns false, iteration will not continue. The iteration order among active +// plugins is not specified. +func (env *Environment) RunMultiPluginHook(hookRunnerFunc multiPluginHookRunnerFunc, hookId int) { env.mutex.RLock() defer env.mutex.RUnlock() for _, activePlugin := range env.activePlugins { - if activePlugin.Supervisor == nil || !activePlugin.Supervisor.Implements(mustImplement) { + if activePlugin.supervisor == nil || !activePlugin.supervisor.Implements(hookId) { continue } - if !hookRunnerFunc(activePlugin.Supervisor.Hooks()) { + if !hookRunnerFunc(activePlugin.supervisor.Hooks()) { break } } diff --git a/plugin/example_hello_world_test.go b/plugin/example_hello_world_test.go new file mode 100644 index 000000000..955c6df3c --- /dev/null +++ b/plugin/example_hello_world_test.go @@ -0,0 +1,20 @@ +package plugin_test + +import ( + "fmt" + "net/http" + + "github.com/mattermost/mattermost-server/plugin" +) + +type HelloWorldPlugin struct{} + +func (p *HelloWorldPlugin) ServeHTTP(c *plugin.Context, w http.ResponseWriter, r *http.Request) { + fmt.Fprintf(w, "Hello, world!") +} + +// This example demonstrates a plugin that handles HTTP requests which respond by greeting the +// world. +func Example_helloWorld() { + plugin.ClientMain(&HelloWorldPlugin{}) +} diff --git a/plugin/example_help_test.go b/plugin/example_help_test.go new file mode 100644 index 000000000..3f9be9a20 --- /dev/null +++ b/plugin/example_help_test.go @@ -0,0 +1,71 @@ +package plugin_test + +import ( + "strings" + + "github.com/mattermost/mattermost-server/model" + "github.com/mattermost/mattermost-server/plugin" +) + +type HelpPlugin struct { + plugin.MattermostPlugin + + TeamName string + ChannelName string + + channelId string +} + +func (p *HelpPlugin) OnConfigurationChange() error { + // Reuse the default implementation of OnConfigurationChange to automatically load the + // required TeamName and ChannelName. + if err := p.MattermostPlugin.OnConfigurationChange(); err != nil { + p.API.LogError(err.Error()) + return nil + } + + team, err := p.API.GetTeamByName(p.TeamName) + if err != nil { + p.API.LogError("failed to find team", "team_name", p.TeamName) + return nil + } + + channel, err := p.API.GetChannelByName(p.ChannelName, team.Id) + if err != nil { + p.API.LogError("failed to find channel", "channel_name", p.ChannelName) + return nil + } + + p.channelId = channel.Id + + return nil +} + +func (p *HelpPlugin) MessageHasBeenPosted(c *plugin.Context, post *model.Post) { + // Ignore posts not in the configured channel + if post.ChannelId != p.channelId { + return + } + + // Ignore posts this plugin made. + if sentByPlugin, _ := post.Props["sent_by_plugin"].(bool); sentByPlugin { + return + } + + // Ignore posts without a plea for help. + if !strings.Contains(post.Message, "help") { + return + } + + p.API.SendEphemeralPost(post.UserId, &model.Post{ + ChannelId: p.channelId, + Message: "You asked for help? Checkout https://about.mattermost.com/help/", + Props: map[string]interface{}{ + "sent_by_plugin": true, + }, + }) +} + +func Example_helpPlugin() { + plugin.ClientMain(&HelpPlugin{}) +} diff --git a/plugin/hclog_adapter.go b/plugin/hclog_adapter.go index 55d60f508..64b1e5243 100644 --- a/plugin/hclog_adapter.go +++ b/plugin/hclog_adapter.go @@ -12,12 +12,12 @@ import ( "github.com/mattermost/mattermost-server/mlog" ) -type HclogAdapter struct { +type hclogAdapter struct { wrappedLogger *mlog.Logger extrasKey string } -func (h *HclogAdapter) Trace(msg string, args ...interface{}) { +func (h *hclogAdapter) Trace(msg string, args ...interface{}) { extras := strings.TrimSpace(fmt.Sprint(args...)) if extras != "" { h.wrappedLogger.Debug(msg, mlog.String(h.extrasKey, extras)) @@ -26,7 +26,7 @@ func (h *HclogAdapter) Trace(msg string, args ...interface{}) { } } -func (h *HclogAdapter) Debug(msg string, args ...interface{}) { +func (h *hclogAdapter) Debug(msg string, args ...interface{}) { extras := strings.TrimSpace(fmt.Sprint(args...)) if extras != "" { h.wrappedLogger.Debug(msg, mlog.String(h.extrasKey, extras)) @@ -35,7 +35,7 @@ func (h *HclogAdapter) Debug(msg string, args ...interface{}) { } } -func (h *HclogAdapter) Info(msg string, args ...interface{}) { +func (h *hclogAdapter) Info(msg string, args ...interface{}) { extras := strings.TrimSpace(fmt.Sprint(args...)) if extras != "" { h.wrappedLogger.Info(msg, mlog.String(h.extrasKey, extras)) @@ -44,7 +44,7 @@ func (h *HclogAdapter) Info(msg string, args ...interface{}) { } } -func (h *HclogAdapter) Warn(msg string, args ...interface{}) { +func (h *hclogAdapter) Warn(msg string, args ...interface{}) { extras := strings.TrimSpace(fmt.Sprint(args...)) if extras != "" { h.wrappedLogger.Warn(msg, mlog.String(h.extrasKey, extras)) @@ -53,7 +53,7 @@ func (h *HclogAdapter) Warn(msg string, args ...interface{}) { } } -func (h *HclogAdapter) Error(msg string, args ...interface{}) { +func (h *hclogAdapter) Error(msg string, args ...interface{}) { extras := strings.TrimSpace(fmt.Sprint(args...)) if extras != "" { h.wrappedLogger.Error(msg, mlog.String(h.extrasKey, extras)) @@ -62,38 +62,38 @@ func (h *HclogAdapter) Error(msg string, args ...interface{}) { } } -func (h *HclogAdapter) IsTrace() bool { +func (h *hclogAdapter) IsTrace() bool { return false } -func (h *HclogAdapter) IsDebug() bool { +func (h *hclogAdapter) IsDebug() bool { return true } -func (h *HclogAdapter) IsInfo() bool { +func (h *hclogAdapter) IsInfo() bool { return true } -func (h *HclogAdapter) IsWarn() bool { +func (h *hclogAdapter) IsWarn() bool { return true } -func (h *HclogAdapter) IsError() bool { +func (h *hclogAdapter) IsError() bool { return true } -func (h *HclogAdapter) With(args ...interface{}) hclog.Logger { +func (h *hclogAdapter) With(args ...interface{}) hclog.Logger { return h } -func (h *HclogAdapter) Named(name string) hclog.Logger { +func (h *hclogAdapter) Named(name string) hclog.Logger { return h } -func (h *HclogAdapter) ResetNamed(name string) hclog.Logger { +func (h *hclogAdapter) ResetNamed(name string) hclog.Logger { return h } -func (h *HclogAdapter) StandardLogger(opts *hclog.StandardLoggerOptions) *log.Logger { +func (h *hclogAdapter) StandardLogger(opts *hclog.StandardLoggerOptions) *log.Logger { return h.wrappedLogger.StdLog() } diff --git a/plugin/hooks.go b/plugin/hooks.go index daeffbc32..5200291f2 100644 --- a/plugin/hooks.go +++ b/plugin/hooks.go @@ -9,8 +9,10 @@ import ( "github.com/mattermost/mattermost-server/model" ) -// These assignments are part of the wire protocol. You can add more, but should not change existing -// assignments. Follow the naming convention of Id as the autogenerated glue code depends on that. +// These assignments are part of the wire protocol used to trigger hook events in plugins. +// +// Feel free to add more, but do not change existing assignments. Follow the naming convention of +// Id as the autogenerated glue code depends on that. const ( OnActivateId = 0 OnDeactivateId = 1 @@ -29,15 +31,16 @@ const ( TotalHooksId = iota ) -// Methods from the Hooks interface can be used by a plugin to respond to events. Methods are likely -// to be added over time, and plugins are not expected to implement all of them. Instead, plugins -// are expected to implement a subset of them and pass an instance to plugin/rpcplugin.Main, which -// will take over execution of the process and add default behaviors for missing hooks. +// Hooks describes the methods a plugin may implement to automatically receive the corresponding +// event. +// +// A plugin only need implement the hooks it cares about. The MattermostPlugin provides some +// default implementations for convenience but may be overridden. type Hooks interface { // OnActivate is invoked when the plugin is activated. OnActivate() error - // Implemented returns a list of hooks that are implmented by the plugin. + // Implemented returns a list of hooks that are implemented by the plugin. // Plugins do not need to provide an implementation. Any given will be ignored. Implemented() ([]string, error) diff --git a/plugin/http.go b/plugin/http.go index 5faf8f08a..7d1650369 100644 --- a/plugin/http.go +++ b/plugin/http.go @@ -9,26 +9,26 @@ import ( "net/rpc" ) -type HTTPResponseWriterRPCServer struct { +type httpResponseWriterRPCServer struct { w http.ResponseWriter } -func (w *HTTPResponseWriterRPCServer) Header(args struct{}, reply *http.Header) error { +func (w *httpResponseWriterRPCServer) Header(args struct{}, reply *http.Header) error { *reply = w.w.Header() return nil } -func (w *HTTPResponseWriterRPCServer) Write(args []byte, reply *struct{}) error { +func (w *httpResponseWriterRPCServer) Write(args []byte, reply *struct{}) error { _, err := w.w.Write(args) return err } -func (w *HTTPResponseWriterRPCServer) WriteHeader(args int, reply *struct{}) error { +func (w *httpResponseWriterRPCServer) WriteHeader(args int, reply *struct{}) error { w.w.WriteHeader(args) return nil } -func (w *HTTPResponseWriterRPCServer) SyncHeader(args http.Header, reply *struct{}) error { +func (w *httpResponseWriterRPCServer) SyncHeader(args http.Header, reply *struct{}) error { dest := w.w.Header() for k := range dest { if _, ok := args[k]; !ok { @@ -41,29 +41,21 @@ func (w *HTTPResponseWriterRPCServer) SyncHeader(args http.Header, reply *struct return nil } -func ServeHTTPResponseWriter(w http.ResponseWriter, conn io.ReadWriteCloser) { - server := rpc.NewServer() - server.Register(&HTTPResponseWriterRPCServer{ - w: w, - }) - server.ServeConn(conn) -} - -type HTTPResponseWriterRPCClient struct { +type httpResponseWriterRPCClient struct { client *rpc.Client header http.Header } -var _ http.ResponseWriter = (*HTTPResponseWriterRPCClient)(nil) +var _ http.ResponseWriter = (*httpResponseWriterRPCClient)(nil) -func (w *HTTPResponseWriterRPCClient) Header() http.Header { +func (w *httpResponseWriterRPCClient) Header() http.Header { if w.header == nil { w.client.Call("Plugin.Header", struct{}{}, &w.header) } return w.header } -func (w *HTTPResponseWriterRPCClient) Write(b []byte) (int, error) { +func (w *httpResponseWriterRPCClient) Write(b []byte) (int, error) { if err := w.client.Call("Plugin.SyncHeader", w.header, nil); err != nil { return 0, err } @@ -73,19 +65,19 @@ func (w *HTTPResponseWriterRPCClient) Write(b []byte) (int, error) { return len(b), nil } -func (w *HTTPResponseWriterRPCClient) WriteHeader(statusCode int) { +func (w *httpResponseWriterRPCClient) WriteHeader(statusCode int) { if err := w.client.Call("Plugin.SyncHeader", w.header, nil); err != nil { return } w.client.Call("Plugin.WriteHeader", statusCode, nil) } -func (h *HTTPResponseWriterRPCClient) Close() error { +func (h *httpResponseWriterRPCClient) Close() error { return h.client.Close() } -func ConnectHTTPResponseWriter(conn io.ReadWriteCloser) *HTTPResponseWriterRPCClient { - return &HTTPResponseWriterRPCClient{ +func connectHTTPResponseWriter(conn io.ReadWriteCloser) *httpResponseWriterRPCClient { + return &httpResponseWriterRPCClient{ client: rpc.NewClient(conn), } } diff --git a/plugin/interface_generator/main.go b/plugin/interface_generator/main.go index 8cbaf4249..4b8b6786f 100644 --- a/plugin/interface_generator/main.go +++ b/plugin/interface_generator/main.go @@ -210,20 +210,20 @@ package plugin {{range .HooksMethods}} func init() { - HookNameToId["{{.Name}}"] = {{.Name}}Id + hookNameToId["{{.Name}}"] = {{.Name}}Id } -type {{.Name}}Args struct { +type {{.Name | obscure}}Args struct { {{structStyle .Params}} } -type {{.Name}}Returns struct { +type {{.Name | obscure}}Returns struct { {{structStyle .Return}} } -func (g *HooksRPCClient) {{.Name}}{{funcStyle .Params}} {{funcStyle .Return}} { - _args := &{{.Name}}Args{ {{valuesOnly .Params}} } - _returns := &{{.Name}}Returns{} +func (g *hooksRPCClient) {{.Name}}{{funcStyle .Params}} {{funcStyle .Return}} { + _args := &{{.Name | obscure}}Args{ {{valuesOnly .Params}} } + _returns := &{{.Name | obscure}}Returns{} if g.implemented[{{.Name}}Id] { if err := g.client.Call("Plugin.{{.Name}}", _args, _returns); err != nil { g.log.Error("RPC call {{.Name}} to plugin failed.", mlog.Err(err)) @@ -232,7 +232,7 @@ func (g *HooksRPCClient) {{.Name}}{{funcStyle .Params}} {{funcStyle .Return}} { return {{destruct "_returns." .Return}} } -func (s *HooksRPCServer) {{.Name}}(args *{{.Name}}Args, returns *{{.Name}}Returns) error { +func (s *hooksRPCServer) {{.Name}}(args *{{.Name | obscure}}Args, returns *{{.Name | obscure}}Returns) error { if hook, ok := s.impl.(interface { {{.Name}}{{funcStyle .Params}} {{funcStyle .Return}} }); ok { @@ -246,24 +246,24 @@ func (s *HooksRPCServer) {{.Name}}(args *{{.Name}}Args, returns *{{.Name}}Return {{range .APIMethods}} -type {{.Name}}Args struct { +type {{.Name | obscure}}Args struct { {{structStyle .Params}} } -type {{.Name}}Returns struct { +type {{.Name | obscure}}Returns struct { {{structStyle .Return}} } -func (g *APIRPCClient) {{.Name}}{{funcStyle .Params}} {{funcStyle .Return}} { - _args := &{{.Name}}Args{ {{valuesOnly .Params}} } - _returns := &{{.Name}}Returns{} +func (g *apiRPCClient) {{.Name}}{{funcStyle .Params}} {{funcStyle .Return}} { + _args := &{{.Name | obscure}}Args{ {{valuesOnly .Params}} } + _returns := &{{.Name | obscure}}Returns{} if err := g.client.Call("Plugin.{{.Name}}", _args, _returns); err != nil { g.log.Error("RPC call to {{.Name}} API failed.", mlog.Err(err)) } return {{destruct "_returns." .Return}} } -func (s *APIRPCServer) {{.Name}}(args *{{.Name}}Args, returns *{{.Name}}Returns) error { +func (s *apiRPCServer) {{.Name}}(args *{{.Name | obscure}}Args, returns *{{.Name | obscure}}Returns) error { if hook, ok := s.impl.(interface { {{.Name}}{{funcStyle .Params}} {{funcStyle .Return}} }); ok { @@ -295,6 +295,9 @@ func generateGlue(info *PluginInterfaceInfo) { "destruct": func(structPrefix string, fields *ast.FieldList) string { return FieldListDestruct(structPrefix, fields, info.FileSet) }, + "obscure": func(name string) string { + return "Z_" + name + }, } hooksTemplate, err := template.New("hooks").Funcs(templateFunctions).Parse(hooksTemplate) diff --git a/plugin/io_rpc.go b/plugin/io_rpc.go index 7bb86b52b..18a1eb525 100644 --- a/plugin/io_rpc.go +++ b/plugin/io_rpc.go @@ -22,15 +22,11 @@ func (rwc *rwc) Close() (err error) { return } -func NewReadWriteCloser(r io.ReadCloser, w io.WriteCloser) io.ReadWriteCloser { - return &rwc{r, w} -} - -type RemoteIOReader struct { +type remoteIOReader struct { conn io.ReadWriteCloser } -func (r *RemoteIOReader) Read(b []byte) (int, error) { +func (r *remoteIOReader) Read(b []byte) (int, error) { var buf [10]byte n := binary.PutVarint(buf[:], int64(len(b))) if _, err := r.conn.Write(buf[:n]); err != nil { @@ -39,15 +35,15 @@ func (r *RemoteIOReader) Read(b []byte) (int, error) { return r.conn.Read(b) } -func (r *RemoteIOReader) Close() error { +func (r *remoteIOReader) Close() error { return r.conn.Close() } -func ConnectIOReader(conn io.ReadWriteCloser) io.ReadCloser { - return &RemoteIOReader{conn} +func connectIOReader(conn io.ReadWriteCloser) io.ReadCloser { + return &remoteIOReader{conn} } -func ServeIOReader(r io.Reader, conn io.ReadWriteCloser) { +func serveIOReader(r io.Reader, conn io.ReadWriteCloser) { cr := bufio.NewReader(conn) defer conn.Close() buf := make([]byte, 32*1024) diff --git a/plugin/request_context.go b/plugin/request_context.go deleted file mode 100644 index a7a3d89fd..000000000 --- a/plugin/request_context.go +++ /dev/null @@ -1,11 +0,0 @@ -// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved. -// See LICENSE.txt for license information. - -package plugin - -type Context struct { -} - -func NewBlankContext() *Context { - return &Context{} -} diff --git a/plugin/supervisor.go b/plugin/supervisor.go index 58a7aa783..1e1005f53 100644 --- a/plugin/supervisor.go +++ b/plugin/supervisor.go @@ -15,25 +15,25 @@ import ( "github.com/mattermost/mattermost-server/model" ) -type Supervisor struct { +type supervisor struct { pluginId string client *plugin.Client hooks Hooks implemented [TotalHooksId]bool } -func NewSupervisor(pluginInfo *model.BundleInfo, parentLogger *mlog.Logger, apiImpl API) (*Supervisor, error) { - supervisor := Supervisor{} +func newSupervisor(pluginInfo *model.BundleInfo, parentLogger *mlog.Logger, apiImpl API) (*supervisor, error) { + supervisor := supervisor{} wrappedLogger := pluginInfo.WrapLogger(parentLogger) - hclogAdaptedLogger := &HclogAdapter{ + hclogAdaptedLogger := &hclogAdapter{ wrappedLogger: wrappedLogger.WithCallerSkip(1), extrasKey: "wrapped_extras", } pluginMap := map[string]plugin.Plugin{ - "hooks": &HooksPlugin{ + "hooks": &hooksPlugin{ log: wrappedLogger, apiImpl: apiImpl, }, @@ -46,7 +46,7 @@ func NewSupervisor(pluginInfo *model.BundleInfo, parentLogger *mlog.Logger, apiI executable = filepath.Join(pluginInfo.Path, executable) supervisor.client = plugin.NewClient(&plugin.ClientConfig{ - HandshakeConfig: Handshake, + HandshakeConfig: handshake, Plugins: pluginMap, Cmd: exec.Command(executable), SyncStdout: wrappedLogger.With(mlog.String("source", "plugin_stdout")).StdLogWriter(), @@ -71,7 +71,7 @@ func NewSupervisor(pluginInfo *model.BundleInfo, parentLogger *mlog.Logger, apiI return nil, err } else { for _, hookName := range impl { - if hookId, ok := HookNameToId[hookName]; ok { + if hookId, ok := hookNameToId[hookName]; ok { supervisor.implemented[hookId] = true } } @@ -85,14 +85,14 @@ func NewSupervisor(pluginInfo *model.BundleInfo, parentLogger *mlog.Logger, apiI return &supervisor, nil } -func (sup *Supervisor) Shutdown() { +func (sup *supervisor) Shutdown() { sup.client.Kill() } -func (sup *Supervisor) Hooks() Hooks { +func (sup *supervisor) Hooks() Hooks { return sup.hooks } -func (sup *Supervisor) Implements(hookId int) bool { +func (sup *supervisor) Implements(hookId int) bool { return sup.implemented[hookId] } diff --git a/plugin/supervisor_test.go b/plugin/supervisor_test.go index ddd04696f..19d0499e5 100644 --- a/plugin/supervisor_test.go +++ b/plugin/supervisor_test.go @@ -73,7 +73,7 @@ func testSupervisor(t *testing.T) { ConsoleLevel: "error", EnableFile: false, }) - supervisor, err := NewSupervisor(bundle, log, &api) + supervisor, err := newSupervisor(bundle, log, &api) require.NoError(t, err) supervisor.Shutdown() } @@ -92,7 +92,7 @@ func testSupervisor_InvalidExecutablePath(t *testing.T) { ConsoleLevel: "error", EnableFile: false, }) - supervisor, err := NewSupervisor(bundle, log, nil) + supervisor, err := newSupervisor(bundle, log, nil) assert.Nil(t, supervisor) assert.Error(t, err) } @@ -111,7 +111,7 @@ func testSupervisor_NonExistentExecutablePath(t *testing.T) { ConsoleLevel: "error", EnableFile: false, }) - supervisor, err := NewSupervisor(bundle, log, nil) + supervisor, err := newSupervisor(bundle, log, nil) require.Error(t, err) require.Nil(t, supervisor) } @@ -141,7 +141,7 @@ func testSupervisor_StartTimeout(t *testing.T) { ConsoleLevel: "error", EnableFile: false, }) - supervisor, err := NewSupervisor(bundle, log, nil) + supervisor, err := newSupervisor(bundle, log, nil) require.Error(t, err) require.Nil(t, supervisor) } diff --git a/plugin/valid.go b/plugin/valid.go index 62c594a1a..5c543e673 100644 --- a/plugin/valid.go +++ b/plugin/valid.go @@ -9,16 +9,23 @@ import ( ) const ( - MinIdLength = 3 - MaxIdLength = 190 + MinIdLength = 3 + MaxIdLength = 190 + ValidIdRegex = `^[a-zA-Z0-9-_\.]+$` ) -var ValidId *regexp.Regexp +// ValidId constrains the set of valid plugin identifiers: +// ^[a-zA-Z0-9-_\.]+ +var validId *regexp.Regexp func init() { - ValidId = regexp.MustCompile(`^[a-zA-Z0-9-_\.]+$`) + validId = regexp.MustCompile(ValidIdRegex) } +// IsValidId verifies that the plugin id has a minimum length of 3, maximum length of 190, and +// contains only alphanumeric characters, dashes, underscores and periods. +// +// These constraints are necessary since the plugin id is used as part of a filesystem path. func IsValidId(id string) bool { if utf8.RuneCountInString(id) < MinIdLength { return false @@ -28,5 +35,5 @@ func IsValidId(id string) bool { return false } - return ValidId.MatchString(id) + return validId.MatchString(id) } -- cgit v1.2.3-1-g7c22