weaviate

1
//                           _       _
2
// __      _____  __ ___   ___  __ _| |_ ___
3
// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
4
//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
5
//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
6
//
7
//  Copyright © 2016 - 2024 Weaviate B.V. All rights reserved.
8
//
9
//  CONTACT: hello@weaviate.io
10
//
11

12
package clients
13

14
import (
15
	"context"
16
	"encoding/json"
17
	"fmt"
18
	"io"
19
	"net/http"
20
	"strings"
21
	"sync"
22

23
	enterrors "github.com/weaviate/weaviate/entities/errors"
24

25
	"github.com/pkg/errors"
26
	"github.com/weaviate/weaviate/modules/text2vec-transformers/ent"
27
)
28

29
func (v *vectorizer) MetaInfo() (map[string]interface{}, error) {
30
	type nameMetaErr struct {
31
		name string
32
		meta map[string]interface{}
33
		err  error
34
	}
35

36
	endpoints := map[string]string{}
37
	if v.originPassage != v.originQuery {
38
		endpoints["passage"] = v.urlPassage("/meta", ent.VectorizationConfig{})
39
		endpoints["query"] = v.urlQuery("/meta", ent.VectorizationConfig{})
40
	} else {
41
		endpoints[""] = v.urlPassage("/meta", ent.VectorizationConfig{})
42
	}
43

44
	var wg sync.WaitGroup
45
	ch := make(chan nameMetaErr, len(endpoints))
46
	for serviceName, endpoint := range endpoints {
47
		serviceName, endpoint := serviceName, endpoint
48
		wg.Add(1)
49
		enterrors.GoWrapper(func() {
50
			defer wg.Done()
51
			meta, err := v.metaInfo(endpoint)
52
			ch <- nameMetaErr{serviceName, meta, err}
53
		}, v.logger)
54
	}
55
	wg.Wait()
56
	close(ch)
57

58
	metas := map[string]interface{}{}
59
	var errs []string
60
	for nme := range ch {
61
		if nme.err != nil {
62
			prefix := ""
63
			if nme.name != "" {
64
				prefix = "[" + nme.name + "] "
65
			}
66
			errs = append(errs, fmt.Sprintf("%s%v", prefix, nme.err.Error()))
67
		}
68
		if nme.meta != nil {
69
			metas[nme.name] = nme.meta
70
		}
71
	}
72

73
	if len(errs) > 0 {
74
		return nil, errors.Errorf(strings.Join(errs, ", "))
75
	}
76
	if len(metas) == 1 {
77
		for _, meta := range metas {
78
			return meta.(map[string]interface{}), nil
79
		}
80
	}
81
	return metas, nil
82
}
83

84
func (v *vectorizer) metaInfo(endpoint string) (map[string]interface{}, error) {
85
	req, err := http.NewRequestWithContext(context.Background(), "GET", endpoint, nil)
86
	if err != nil {
87
		return nil, errors.Wrap(err, "create GET meta request")
88
	}
89

90
	res, err := v.httpClient.Do(req)
91
	if err != nil {
92
		return nil, errors.Wrap(err, "send GET meta request")
93
	}
94
	defer res.Body.Close()
95
	if !(res.StatusCode >= http.StatusOK && res.StatusCode < http.StatusMultipleChoices) {
96
		return nil, errors.Errorf("unexpected status code '%d' of meta request", res.StatusCode)
97
	}
98

99
	bodyBytes, err := io.ReadAll(res.Body)
100
	if err != nil {
101
		return nil, errors.Wrap(err, "read meta response body")
102
	}
103

104
	var resBody map[string]interface{}
105
	if err := json.Unmarshal(bodyBytes, &resBody); err != nil {
106
		return nil, errors.Wrap(err, "unmarshal meta response body")
107
	}
108
	return resBody, nil
109
}
110