ziggi/mproxy
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

working commit

Browse Source
This commit is contained in:
Олег Бородин
2026-05-29 19:07:59 +02:00
parent 4e2c548e97
commit c1f85e87c9
23 changed files with 543 additions and 342 deletions
Download Patch File Download Diff File Expand all files Collapse all files
pkg/servcli/authmw.go
+58
View File
@@ -0,0 +1,58 @@
package servcli
import (
"encoding/base64"
"net/http"
)
// BasicAuthMiddleware
func NewBasicAuthMiddleware(user, pass string) MiddlewareFunc {
return func(next http.RoundTripper) http.RoundTripper {
return newBasicAuthMW(next, user, pass)
}
}
type BasicAuthMW struct {
user, pass string
next http.RoundTripper
}
func newBasicAuthMW(next http.RoundTripper, user, pass string) *BasicAuthMW {
return &BasicAuthMW{
user: user,
pass: pass,
next: next,
}
}
func (tran BasicAuthMW) RoundTrip(req *http.Request) (*http.Response, error) {
if tran.user != "" && tran.pass != "" {
pair := base64.StdEncoding.EncodeToString([]byte(tran.user + ":" + tran.pass))
req.Header.Set("Authorization", "Basic "+pair)
}
return tran.next.RoundTrip(req)
}
// BearerAuthMiddleware
func NewBearerAuthMiddleware(token string) MiddlewareFunc {
return func(next http.RoundTripper) http.RoundTripper {
return newBearerAuthMW(next, token)
}
}
type BearerAuthMW struct {
token string
next http.RoundTripper
}
func newBearerAuthMW(next http.RoundTripper, token string) *BearerAuthMW {
return &BearerAuthMW{
token: token,
next: next,
}
}
func (tran BearerAuthMW) RoundTrip(req *http.Request) (*http.Response, error) {
req.Header.Set("Authorization", "Bearer "+tran.token)
return tran.next.RoundTrip(req)
}
pkg/servcli/client.go
+3 -98
View File
@@ -1,11 +1,11 @@
package servcli
import (
"crypto/tls"
"encoding/base64"
"net/http"
)
type MiddlewareFunc func(next http.RoundTripper) http.RoundTripper
type Client struct {
httpClient *http.Client
userAgent string
@@ -21,10 +21,9 @@ func NewClient(transport http.RoundTripper, mwFuncs ...MiddlewareFunc) *Client {
httpClient := &http.Client{
Transport: transport,
}
return &Client{
httpClient: httpClient,
userAgent: "ociClient/1.0",
userAgent: "proxyClient/1.0",
}
}
@@ -32,100 +31,6 @@ func (cli *Client) SetTransport(transport http.RoundTripper) {
cli.httpClient.Transport = transport
}
type MiddlewareFunc func(next http.RoundTripper) http.RoundTripper
func (cli *Client) UseMiddleware(mwFunc MiddlewareFunc) {
cli.httpClient.Transport = mwFunc(cli.httpClient.Transport)
}
// BasicAuthMiddleware
func NewBasicAuthMiddleware(user, pass string) MiddlewareFunc {
return func(next http.RoundTripper) http.RoundTripper {
return newBasicAuthMW(next, user, pass)
}
}
type BasicAuthMW struct {
user, pass string
next http.RoundTripper
}
func newBasicAuthMW(next http.RoundTripper, user, pass string) *BasicAuthMW {
return &BasicAuthMW{
user: user,
pass: pass,
next: next,
}
}
func (tran BasicAuthMW) RoundTrip(req *http.Request) (*http.Response, error) {
if tran.user != "" && tran.pass != "" {
pair := base64.StdEncoding.EncodeToString([]byte(tran.user + ":" + tran.pass))
req.Header.Set("Authorization", "Basic "+pair)
}
return tran.next.RoundTrip(req)
}
// BearerAuthMiddleware
func NewBearerAuthMiddleware(token string) MiddlewareFunc {
return func(next http.RoundTripper) http.RoundTripper {
return newBearerAuthMW(next, token)
}
}
type BearerAuthMW struct {
token string
next http.RoundTripper
}
func newBearerAuthMW(next http.RoundTripper, token string) *BearerAuthMW {
return &BearerAuthMW{
token: token,
next: next,
}
}
func (tran BearerAuthMW) RoundTrip(req *http.Request) (*http.Response, error) {
req.Header.Set("Authorization", "Bearer "+tran.token)
return tran.next.RoundTrip(req)
}
// DefaultTransport
type DefaultTransport struct {
transport http.RoundTripper
}
func NewDefaultTransport() *DefaultTransport {
return &DefaultTransport{
transport: &http.Transport{
TLSClientConfig: &tls.Config{
InsecureSkipVerify: true,
},
},
}
}
func (wrap *DefaultTransport) RoundTrip(req *http.Request) (*http.Response, error) {
return wrap.transport.RoundTrip(req)
}
// ExampleMiddleware
func NewExampleMiddleware() MiddlewareFunc {
return func(next http.RoundTripper) http.RoundTripper {
return newExampleTransport(next)
}
}
type ExampleTransport struct {
next http.RoundTripper
}
func newExampleTransport(next http.RoundTripper) *ExampleTransport {
return &ExampleTransport{
next: next,
}
}
func (tran ExampleTransport) RoundTrip(req *http.Request) (*http.Response, error) {
return tran.next.RoundTrip(req)
}
pkg/servcli/copyctx.go
+42
View File
@@ -0,0 +1,42 @@
/*
* Copyright 2026 Oleg Borodin <onborodin@gmail.com>
*/
package servcli
import (
"context"
"errors"
"io"
)
func Copy(ctx context.Context, writer io.Writer, reader io.Reader) (int64, error) {
var err error
var size int64
var halt bool
buffer := make([]byte, 1024*4)
for {
select {
case <-ctx.Done():
err = errors.New("Break copy by context")
break
default:
}
rsize, err := reader.Read(buffer)
if err == io.EOF {
err = nil
halt = true
}
if err != nil {
return size, err
}
wsize, err := writer.Write(buffer[0:rsize])
size += int64(wsize)
if err != nil {
return size, err
}
if halt {
break
}
}
return size, err
}
pkg/servcli/gethello.go
+77
View File
@@ -0,0 +1,77 @@
/*
* Copyright 2026 Oleg Borodin <onborodin@gmail.com>
*/
package servcli
import (
"bytes"
"context"
"encoding/json"
"fmt"
"net/http"
"strconv"
"mproxy/app/servoper"
)
func (cli *Client) GetHello(ctx context.Context, rawpath string) error {
var err error
req := servoper.GetHelloParams{}
reqdata, err := json.Marshal(req)
if err != nil {
return err
}
_, err = cli.DoCall(ctx, rawpath, reqdata)
if err != nil {
return err
}
return err
}
func (cli *Client) DoCall(ctx context.Context, rawpath string, reqdata []byte) ([]byte, error) {
var err error
res := make([]byte, 0)
ref, err := ParsePath(rawpath)
if err != nil {
return res, err
}
uri := ref.HelloEP()
reader := bytes.NewReader(reqdata)
req, err := http.NewRequestWithContext(ctx, http.MethodPost, uri, reader)
if err != nil {
return res, err
}
req.Header.Set("User-Agent", cli.userAgent)
req.Header.Set("Accept", "*/*")
resp, err := cli.httpClient.Do(req)
if err != nil {
return res, err
}
defer resp.Body.Close()
if resp.StatusCode == http.StatusNotFound {
return res, err
}
if resp.StatusCode != http.StatusOK {
err := fmt.Errorf("Unexpected response code %s", resp.Status)
return res, err
}
contentLength := resp.Header.Get("Content-Length")
if contentLength == "" {
err := fmt.Errorf("Content-Length header is missing")
return res, err
}
blobSize, err := strconv.ParseInt(contentLength, 10, 64)
if err != nil {
return res, err
}
buffer := bytes.NewBuffer(nil)
recSize, err := Copy(ctx, buffer, resp.Body)
if blobSize != recSize {
err := fmt.Errorf("Mismatch declared and actual body size: %d and %d", blobSize, recSize)
return res, err
}
res = buffer.Bytes()
return res, err
}
pkg/servcli/httpcall.go
-56
View File
@@ -1,56 +0,0 @@
/*
* Copyright 2026 Oleg Borodin <onborodin@gmail.com>
*/
package servcli
import (
"bytes"
"context"
"fmt"
"io"
"net/http"
"strconv"
)
func (cli *Client) doHTTPCall(ctx context.Context, host, obj, oper string, req []byte) ([]byte, error) {
var err error
var res []byte
reader := bytes.NewReader(req)
ref, err := NewReferer(host, obj, oper)
if err != nil {
return res, err
}
httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, ref.Point(), reader)
if err != nil {
return res, err
}
httpReq.Header.Set("User-Agent", cli.userAgent)
httpReq.Header.Set("Accept", "*/*")
httpResp, err := cli.httpClient.Do(httpReq)
if err != nil {
return res, err
}
defer httpResp.Body.Close()
if httpResp.StatusCode != http.StatusOK {
err := fmt.Errorf("Unexpected response code: %s", httpResp.Status)
return res, err
}
contentLength := httpResp.Header.Get("Content-Length")
if contentLength == "" {
err := fmt.Errorf("Content-Length header is missing")
return res, err
}
blobSize, err := strconv.ParseInt(contentLength, 10, 64)
if err != nil {
return res, err
}
buffer := bytes.NewBuffer(nil)
recSize, err := io.Copy(buffer, httpResp.Body)
if blobSize != recSize {
err := fmt.Errorf("Mismatch declared and actual body size, %d and %d", blobSize, recSize)
return res, err
}
res = buffer.Bytes()
return res, err
}
pkg/servcli/referer.go
+43 -33
View File
@@ -1,26 +1,36 @@
/*
* Copyright 2026 Oleg Borodin <onborodin@gmail.com>
*/
package servcli
import (
"net/url"
"path"
"strconv"
"strings"
)
const (
PathTypeIdentic = "identic"
PathTypePrefix = "prefix"
PathTypeRegexp = "regexp"
)
type Referer struct {
urlobj *url.URL
user, pass string
obj, oper string
resource string
values url.Values
}
func NewReferer(hostname, object, operation string) (*Referer, error) {
func ParsePath(rawpath string) (*Referer, error) {
ref := &Referer{
obj: object,
oper: operation,
values: url.Values{},
}
if !strings.Contains(hostname, "://") {
hostname = "https://" + hostname
if !strings.Contains(rawpath, "://") {
rawpath = "https://" + rawpath
}
urlobj, err := url.Parse(hostname)
urlobj, err := url.Parse(rawpath)
if err != nil {
return ref, err
}
@@ -29,40 +39,40 @@ func NewReferer(hostname, object, operation string) (*Referer, error) {
ref.pass, _ = urlobj.User.Password()
urlobj.User = nil
}
ref.resource = path.Join("/", urlobj.Path)
urlobj.Path = "/"
ref.urlobj = urlobj
ref.values = urlobj.Query()
return ref, err
}
func ParseHostinfo(hostname string) (*Referer, error) {
ref := &Referer{}
if !strings.Contains(hostname, "://") {
hostname = "https://" + hostname
}
urlobj, err := url.Parse(hostname)
if err != nil {
return ref, err
}
if urlobj.User != nil {
ref.user = urlobj.User.Username()
ref.pass, _ = urlobj.User.Password()
urlobj.User = nil
}
urlobj.Path = "/"
ref.urlobj = urlobj
return ref, err
}
func (ref *Referer) Host() string {
return ref.urlobj.Host
}
func (ref *Referer) Raw() string {
return path.Join(ref.urlobj.Host, "/v3/api/", ref.obj, ref.oper)
res := path.Join(ref.urlobj.Host, ref.resource)
query := ref.values.Encode()
if query != "" {
return res + "?" + query
}
return res
}
func (ref *Referer) Point() string {
curl := ref.urlobj.JoinPath("/v3/api/", ref.obj, ref.oper)
func (ref *Referer) SetResource(resource string) {
ref.resource = path.Join("/", resource)
}
func (ref *Referer) JoinResource(resource string) {
ref.resource = path.Join("/", ref.resource, resource)
}
func (ref *Referer) PathType(typ string) {
ref.values.Set("pathType", typ)
}
func (ref *Referer) DryRun(yesno bool) {
ref.values.Set("dryRun", strconv.FormatBool(yesno))
}
func (ref *Referer) HelloEP() string {
curl := ref.urlobj.JoinPath("/v3/api/service/hello", ref.resource)
return curl.String()
}
pkg/servcli/servhello.go
-36
View File
@@ -1,36 +0,0 @@
package servcli
import (
"context"
"encoding/json"
"errors"
"mproxy/app/handler"
"mproxy/app/servoper"
)
func (cli *Client) ServiceHello(ctx context.Context, host string) (bool, error) {
var res bool
var err error
params := servoper.SendHelloParams{}
reqdata, err := json.Marshal(params)
if err != nil {
return res, err
}
resdata, err := cli.doHTTPCall(ctx, host, "service", "hello", reqdata)
if err != nil {
return res, err
}
response := handler.Response[servoper.SendHelloResult]{}
err = json.Unmarshal(resdata, &response)
if err != nil {
return res, err
}
if response.Error {
err = errors.New(response.Message)
return res, err
}
res = response.Result.Alive
return res, err
}
pkg/servcli/transp.go
+25
View File
@@ -0,0 +1,25 @@
package servcli
import (
"crypto/tls"
"net/http"
)
// DefaultTransport
type DefaultTransport struct {
transport http.RoundTripper
}
func NewDefaultTransport() *DefaultTransport {
return &DefaultTransport{
transport: &http.Transport{
TLSClientConfig: &tls.Config{
InsecureSkipVerify: true,
},
},
}
}
func (wrap *DefaultTransport) RoundTrip(req *http.Request) (*http.Response, error) {
return wrap.transport.RoundTrip(req)
}