mirror of
https://github.com/hanzoai/team.git
synced 2026-09-30 01:57:35 +00:00
zeekay
8feb24ea1f
The server module named github.com/hanzoai/team/server/v8 — a path that resolves to the retired workspace's repository, not this one — while server/public still published github.com/mattermost/mattermost/server/public. Both are github.com/hanzoteam/server/... now, which is where this code actually lives. That second half is what made the binary unbootable. Upstream's public path stayed claimed by upstream, mattermost-plugin-ai imported it, and the build linked public/model twice; public/plugin's gob.Register then ran twice under one name and panicked at init, before main. Reverting the rename traded the brand for a working binary. Rebranding the plugin alongside it needs no such trade: the agents fork is github.com/hanzoteam/agents/v2 against our public module, so no module named mattermost/mattermost is in the graph at all. Measured: `go list -deps ./cmd/mattermost` names exactly one public/model, and it is ours.
120 lines
3.0 KiB
Go
120 lines
3.0 KiB
Go
// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
|
|
// See LICENSE.txt for license information.
|
|
|
|
package plugin
|
|
|
|
import (
|
|
"bufio"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"maps"
|
|
"net"
|
|
"net/http"
|
|
"net/rpc"
|
|
|
|
"github.com/hanzoteam/server/server/public/shared/mlog"
|
|
)
|
|
|
|
type hijackedResponse struct {
|
|
conn net.Conn
|
|
bufrw *bufio.ReadWriter
|
|
readBuf []byte
|
|
}
|
|
|
|
type httpResponseWriterRPCServer struct {
|
|
w http.ResponseWriter
|
|
log *mlog.Logger
|
|
hjr *hijackedResponse
|
|
}
|
|
|
|
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 {
|
|
_, err := w.w.Write(args)
|
|
return err
|
|
}
|
|
|
|
func (w *httpResponseWriterRPCServer) WriteHeader(args int, reply *struct{}) error {
|
|
// Check if args is a valid http status code. This prevents plugins from crashing the server with a panic.
|
|
// This is a copy of the checkWriteHeaderCode function in net/http/server.go in the go source.
|
|
if args < 100 || args > 999 {
|
|
w.log.Error(fmt.Sprintf("Plugin tried to write an invalid http status code: %v. Did not write the invalid header.", args))
|
|
return errors.New("invalid http status code")
|
|
}
|
|
w.w.WriteHeader(args)
|
|
return nil
|
|
}
|
|
|
|
func (w *httpResponseWriterRPCServer) SyncHeader(args http.Header, reply *struct{}) error {
|
|
dest := w.w.Header()
|
|
for k := range dest {
|
|
if _, ok := args[k]; !ok {
|
|
delete(dest, k)
|
|
}
|
|
}
|
|
maps.Copy(dest, args)
|
|
return nil
|
|
}
|
|
|
|
func (w *httpResponseWriterRPCServer) Flush(args struct{}, reply *struct{}) error {
|
|
// Type assert to http.Flusher and flush if supported
|
|
if flusher, ok := w.w.(http.Flusher); ok {
|
|
flusher.Flush()
|
|
}
|
|
// If the underlying writer doesn't support Flusher, silently ignore
|
|
// This matches the HTTP spec's "best effort" semantics
|
|
return nil
|
|
}
|
|
|
|
type httpResponseWriterRPCClient struct {
|
|
client *rpc.Client
|
|
header http.Header
|
|
}
|
|
|
|
var _ http.ResponseWriter = (*httpResponseWriterRPCClient)(nil)
|
|
var _ http.Flusher = (*httpResponseWriterRPCClient)(nil)
|
|
|
|
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) {
|
|
if err := w.client.Call("Plugin.SyncHeader", w.header, nil); err != nil {
|
|
return 0, err
|
|
}
|
|
if err := w.client.Call("Plugin.Write", b, nil); err != nil {
|
|
return 0, err
|
|
}
|
|
return len(b), nil
|
|
}
|
|
|
|
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)
|
|
}
|
|
|
|
// Flush implements http.Flusher interface
|
|
func (w *httpResponseWriterRPCClient) Flush() {
|
|
// Best-effort flush - ignore errors per HTTP spec
|
|
w.client.Call("Plugin.Flush", struct{}{}, nil)
|
|
}
|
|
|
|
func (w *httpResponseWriterRPCClient) Close() error {
|
|
return w.client.Close()
|
|
}
|
|
|
|
func connectHTTPResponseWriter(conn io.ReadWriteCloser) *httpResponseWriterRPCClient {
|
|
return &httpResponseWriterRPCClient{
|
|
client: rpc.NewClient(conn),
|
|
}
|
|
}
|