_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q15200 | SetListenAddress | train | func (p *Prometheus) SetListenAddress(address string) {
p.listenAddress = address
if p.listenAddress != "" {
p.router = gin.Default()
}
} | go | {
"resource": ""
} |
q15201 | SetMetricsPath | train | func (p *Prometheus) SetMetricsPath(e *gin.Engine) {
if p.listenAddress != "" {
p.router.GET(p.MetricsPath, prometheusHandler())
p.runServer()
} else {
e.GET(p.MetricsPath, prometheusHandler())
}
} | go | {
"resource": ""
} |
q15202 | SetMetricsPathWithAuth | train | func (p *Prometheus) SetMetricsPathWithAuth(e *gin.Engine, accounts gin.Accounts) {
if p.listenAddress != "" {
p.router.GET(p.MetricsPath, gin.BasicAuth(accounts), prometheusHandler())
p.runServer()
} else {
e.GET(p.MetricsPath, gin.BasicAuth(accounts), prometheusHandler())
}
} | go | {
"resource": ""
} |
q15203 | NewMetric | train | func NewMetric(m *Metric, subsystem string) prometheus.Collector {
var metric prometheus.Collector
switch m.Type {
case "counter_vec":
metric = prometheus.NewCounterVec(
prometheus.CounterOpts{
Subsystem: subsystem,
Name: m.Name,
Help: m.Description,
},
m.Args,
)
case "counter":
... | go | {
"resource": ""
} |
q15204 | Use | train | func (p *Prometheus) Use(e *gin.Engine) {
e.Use(p.HandlerFunc())
p.SetMetricsPath(e)
} | go | {
"resource": ""
} |
q15205 | UseWithAuth | train | func (p *Prometheus) UseWithAuth(e *gin.Engine, accounts gin.Accounts) {
e.Use(p.HandlerFunc())
p.SetMetricsPathWithAuth(e, accounts)
} | go | {
"resource": ""
} |
q15206 | HandlerFunc | train | func (p *Prometheus) HandlerFunc() gin.HandlerFunc {
return func(c *gin.Context) {
if c.Request.URL.String() == p.MetricsPath {
c.Next()
return
}
start := time.Now()
reqSz := computeApproximateRequestSize(c.Request)
c.Next()
status := strconv.Itoa(c.Writer.Status())
elapsed := float64(time.Since... | go | {
"resource": ""
} |
q15207 | findBlice | train | func (m *Matcher) findBlice(b []byte) *node {
n := &m.trie[0]
for n != nil && len(b) > 0 {
n = n.child[int(b[0])]
b = b[1:]
}
return n
} | go | {
"resource": ""
} |
q15208 | buildTrie | train | func (m *Matcher) buildTrie(dictionary [][]byte) {
// Work out the maximum size for the trie (all dictionary entries
// are distinct plus the root). This is used to preallocate memory
// for it.
max := 1
for _, blice := range dictionary {
max += len(blice)
}
m.trie = make([]node, max)
// Calling this an ig... | go | {
"resource": ""
} |
q15209 | NewMatcher | train | func NewMatcher(dictionary [][]byte) *Matcher {
m := new(Matcher)
m.buildTrie(dictionary)
return m
} | go | {
"resource": ""
} |
q15210 | Match | train | func (m *Matcher) Match(in []byte) []int {
m.counter += 1
var hits []int
n := m.root
for _, b := range in {
c := int(b)
if !n.root && n.child[c] == nil {
n = n.fails[c]
}
if n.child[c] != nil {
f := n.child[c]
n = f
if f.output && f.counter != m.counter {
hits = append(hits, f.index)
... | go | {
"resource": ""
} |
q15211 | stopHandler | train | func stopHandler(stopurl string, cancel bool, wrapped fetchbot.Handler) fetchbot.Handler {
return fetchbot.HandlerFunc(func(ctx *fetchbot.Context, res *http.Response, err error) {
if ctx.Cmd.URL().String() == stopurl {
fmt.Printf(">>>>> STOP URL %s\n", ctx.Cmd.URL())
// generally not a good idea to stop/block ... | go | {
"resource": ""
} |
q15212 | logHandler | train | func logHandler(wrapped fetchbot.Handler) fetchbot.Handler {
return fetchbot.HandlerFunc(func(ctx *fetchbot.Context, res *http.Response, err error) {
if err == nil {
fmt.Printf("[%d] %s %s - %s\n", res.StatusCode, ctx.Cmd.Method(), ctx.Cmd.URL(), res.Header.Get("Content-Type"))
}
wrapped.Handle(ctx, res, err)... | go | {
"resource": ""
} |
q15213 | NewHandlerCmd | train | func NewHandlerCmd(method, rawURL string, fn func(*Context, *http.Response, error)) (*HandlerCmd, error) {
parsedURL, err := url.Parse(rawURL)
if err != nil {
return nil, err
}
return &HandlerCmd{&Cmd{parsedURL, method}, HandlerFunc(fn)}, nil
} | go | {
"resource": ""
} |
q15214 | Handle | train | func (h HandlerFunc) Handle(ctx *Context, res *http.Response, err error) {
h(ctx, res, err)
} | go | {
"resource": ""
} |
q15215 | NewMux | train | func NewMux() *Mux {
return &Mux{
// Default handler is a no-op
DefaultHandler: HandlerFunc(func(ctx *Context, res *http.Response, err error) {}),
errm: make(map[error]Handler),
res: make(map[*ResponseMatcher]bool),
}
} | go | {
"resource": ""
} |
q15216 | Handle | train | func (mux *Mux) Handle(ctx *Context, res *http.Response, err error) {
mux.mu.RLock()
defer mux.mu.RUnlock()
if err != nil {
// Find a matching error handler
if h, ok := mux.errm[err]; ok {
h.Handle(ctx, res, err)
return
}
if h, ok := mux.errm[nil]; ok {
h.Handle(ctx, res, err)
return
}
} else ... | go | {
"resource": ""
} |
q15217 | HandleError | train | func (mux *Mux) HandleError(err error, h Handler) {
mux.mu.Lock()
defer mux.mu.Unlock()
mux.errm[err] = h
} | go | {
"resource": ""
} |
q15218 | match | train | func (r *ResponseMatcher) match(res *http.Response) (bool, int) {
if r.method != "" {
if r.method != res.Request.Method {
return false, 0
}
}
if r.contentType != "" {
if r.contentType != getContentType(res.Header.Get("Content-Type")) {
return false, 0
}
}
if r.minStatus != 0 || r.maxStatus != 0 {
i... | go | {
"resource": ""
} |
q15219 | Status | train | func (r *ResponseMatcher) Status(code int) *ResponseMatcher {
r.mux.mu.Lock()
defer r.mux.mu.Unlock()
r.minStatus = code
r.maxStatus = code
return r
} | go | {
"resource": ""
} |
q15220 | StatusRange | train | func (r *ResponseMatcher) StatusRange(min, max int) *ResponseMatcher {
if min > max {
min, max = max, min
}
r.mux.mu.Lock()
defer r.mux.mu.Unlock()
r.minStatus = min
r.maxStatus = max
return r
} | go | {
"resource": ""
} |
q15221 | Scheme | train | func (r *ResponseMatcher) Scheme(scheme string) *ResponseMatcher {
r.mux.mu.Lock()
defer r.mux.mu.Unlock()
r.scheme = scheme
return r
} | go | {
"resource": ""
} |
q15222 | Host | train | func (r *ResponseMatcher) Host(host string) *ResponseMatcher {
r.mux.mu.Lock()
defer r.mux.mu.Unlock()
r.host = host
return r
} | go | {
"resource": ""
} |
q15223 | Path | train | func (r *ResponseMatcher) Path(p string) *ResponseMatcher {
r.mux.mu.Lock()
defer r.mux.mu.Unlock()
r.path = p
return r
} | go | {
"resource": ""
} |
q15224 | Custom | train | func (r *ResponseMatcher) Custom(predicate func(*http.Response) bool) *ResponseMatcher {
r.mux.mu.Lock()
defer r.mux.mu.Unlock()
r.predicate = predicate
return r
} | go | {
"resource": ""
} |
q15225 | Handler | train | func (r *ResponseMatcher) Handler(h Handler) *ResponseMatcher {
r.mux.mu.Lock()
defer r.mux.mu.Unlock()
r.h = h
if !r.mux.res[r] {
r.mux.res[r] = true
}
return r
} | go | {
"resource": ""
} |
q15226 | New | train | func New(h Handler) *Fetcher {
return &Fetcher{
Handler: h,
CrawlDelay: DefaultCrawlDelay,
HttpClient: http.DefaultClient,
UserAgent: DefaultUserAgent,
WorkerIdleTTL: DefaultWorkerIdleTTL,
dbg: make(chan *DebugInfo, 1),
}
} | go | {
"resource": ""
} |
q15227 | Close | train | func (q *Queue) Close() error {
// Make sure it is not already closed, as this is a run-time panic
select {
case <-q.closed:
// Already closed, no-op
return nil
default:
// Close the signal-channel
close(q.closed)
// Send a nil Command to make sure the processQueue method sees the close signal.
q.ch <- ... | go | {
"resource": ""
} |
q15228 | Cancel | train | func (q *Queue) Cancel() error {
select {
case <-q.cancelled:
// already cancelled, no-op
return nil
default:
// mark the queue as cancelled
close(q.cancelled)
// Close the Queue, that will wait for pending commands to drain
// will unblock any callers waiting on q.Block
return q.Close()
}
} | go | {
"resource": ""
} |
q15229 | Send | train | func (q *Queue) Send(c Command) error {
if c == nil {
return ErrEmptyHost
}
if u := c.URL(); u == nil || u.Host == "" {
return ErrEmptyHost
}
select {
case <-q.closed:
return ErrQueueClosed
default:
q.ch <- c
}
return nil
} | go | {
"resource": ""
} |
q15230 | SendString | train | func (q *Queue) SendString(method string, rawurl ...string) (int, error) {
return q.sendWithMethod(method, rawurl)
} | go | {
"resource": ""
} |
q15231 | SendStringHead | train | func (q *Queue) SendStringHead(rawurl ...string) (int, error) {
return q.sendWithMethod("HEAD", rawurl)
} | go | {
"resource": ""
} |
q15232 | SendStringGet | train | func (q *Queue) SendStringGet(rawurl ...string) (int, error) {
return q.sendWithMethod("GET", rawurl)
} | go | {
"resource": ""
} |
q15233 | Start | train | func (f *Fetcher) Start() *Queue {
f.hosts = make(map[string]chan Command)
f.q = &Queue{
ch: make(chan Command, 1),
closed: make(chan struct{}),
cancelled: make(chan struct{}),
done: make(chan struct{}),
}
// Start the one and only queue processing goroutine.
f.q.wg.Add(1)
go f.processQue... | go | {
"resource": ""
} |
q15234 | Debug | train | func (f *Fetcher) Debug() <-chan *DebugInfo {
f.dbgmu.Lock()
defer f.dbgmu.Unlock()
f.debugging = true
return f.dbg
} | go | {
"resource": ""
} |
q15235 | processQueue | train | func (f *Fetcher) processQueue() {
loop:
for v := range f.q.ch {
if v == nil {
// Special case, when the Queue is closed, a nil command is sent, use this
// indicator to check for the closed signal, instead of looking on every loop.
select {
case <-f.q.closed:
// Close signal, exit loop
break loo... | go | {
"resource": ""
} |
q15236 | processChan | train | func (f *Fetcher) processChan(ch <-chan Command, hostKey string) {
var (
agent *robotstxt.Group
wait <-chan time.Time
ttl <-chan time.Time
delay = f.CrawlDelay
)
loop:
for {
select {
case <-f.q.cancelled:
break loop
case v, ok := <-ch:
if !ok {
// Terminate this goroutine, channel is clos... | go | {
"resource": ""
} |
q15237 | getRobotAgent | train | func (f *Fetcher) getRobotAgent(r robotCommand) *robotstxt.Group {
res, err := f.doRequest(r)
if err != nil {
// TODO: Ignore robots.txt request error?
fmt.Fprintf(os.Stderr, "fetchbot: error fetching robots.txt: %s\n", err)
return nil
}
if res.Body != nil {
defer res.Body.Close()
}
robData, err := robots... | go | {
"resource": ""
} |
q15238 | visit | train | func (f *Fetcher) visit(cmd Command, res *http.Response, err error) {
if res != nil && res.Body != nil {
defer res.Body.Close()
}
// if the Command implements Handler, call that handler, otherwise
// dispatch to the Fetcher's Handler.
if h, ok := cmd.(Handler); ok {
h.Handle(&Context{Cmd: cmd, Q: f.q}, res, er... | go | {
"resource": ""
} |
q15239 | doRequest | train | func (f *Fetcher) doRequest(cmd Command) (*http.Response, error) {
req, err := http.NewRequest(cmd.Method(), cmd.URL().String(), nil)
if err != nil {
return nil, err
}
// If the Command implements some other recognized interfaces, set
// the request accordingly (see cmd.go for the list of interfaces).
// First,... | go | {
"resource": ""
} |
q15240 | sliceIQ | train | func sliceIQ(in <-chan Command, next chan<- Command) {
defer close(next)
// pending events (this is the "infinite" part)
pending := []Command{}
recv:
for {
// Ensure that pending always has values so the select can
// multiplex between the receiver and sender properly
if len(pending) == 0 {
v, ok := <-in... | go | {
"resource": ""
} |
q15241 | NewPQueue | train | func NewPQueue(pqType PQType) *PQueue {
var cmp func(int, int) bool
if pqType == MAXPQ {
cmp = max
} else {
cmp = min
}
items := make([]*item, 1)
items[0] = nil // Heap queue first element should always be nil
return &PQueue{
items: items,
elemsCount: 0,
comparator: cmp,
}
} | go | {
"resource": ""
} |
q15242 | Push | train | func (pq *PQueue) Push(value interface{}, priority int) {
item := newItem(value, priority)
pq.Lock()
pq.items = append(pq.items, item)
pq.elemsCount += 1
pq.swim(pq.size())
pq.Unlock()
} | go | {
"resource": ""
} |
q15243 | Size | train | func (pq *PQueue) Size() int {
pq.RLock()
defer pq.RUnlock()
return pq.size()
} | go | {
"resource": ""
} |
q15244 | Empty | train | func (pq *PQueue) Empty() bool {
pq.RLock()
defer pq.RUnlock()
return pq.size() == 0
} | go | {
"resource": ""
} |
q15245 | NewCappedDeque | train | func NewCappedDeque(capacity int) *Deque {
return &Deque{
container: list.New(),
capacity: capacity,
}
} | go | {
"resource": ""
} |
q15246 | Size | train | func (s *Deque) Size() int {
s.RLock()
defer s.RUnlock()
return s.container.Len()
} | go | {
"resource": ""
} |
q15247 | Capacity | train | func (s *Deque) Capacity() int {
s.RLock()
defer s.RUnlock()
return s.capacity
} | go | {
"resource": ""
} |
q15248 | Empty | train | func (s *Deque) Empty() bool {
s.RLock()
defer s.RUnlock()
return s.container.Len() == 0
} | go | {
"resource": ""
} |
q15249 | Full | train | func (s *Deque) Full() bool {
s.RLock()
defer s.RUnlock()
return s.capacity >= 0 && s.container.Len() >= s.capacity
} | go | {
"resource": ""
} |
q15250 | AddSchedulerTaskFromTask | train | func AddSchedulerTaskFromTask(t core.Task) Task {
st := SchedulerTaskFromTask(t)
(&st).assertSchedule(t.Schedule())
st.Workflow = t.WMap()
return st
} | go | {
"resource": ""
} |
q15251 | SecurityTLSEnabled | train | func SecurityTLSEnabled(certPath, keyPath string, secureSide SecureSide) GRPCSecurity {
return GRPCSecurity{
TLSEnabled: true,
SecureSide: secureSide,
TLSCertPath: certPath,
TLSKeyPath: keyPath,
}
} | go | {
"resource": ""
} |
q15252 | SecurityTLSExtended | train | func SecurityTLSExtended(certPath, keyPath string, secureSide SecureSide, caCertPaths []string) GRPCSecurity {
return GRPCSecurity{
TLSEnabled: true,
SecureSide: secureSide,
TLSCertPath: certPath,
TLSKeyPath: keyPath,
CACertPaths: caCertPaths,
}
} | go | {
"resource": ""
} |
q15253 | NewCollectorGrpcClient | train | func NewCollectorGrpcClient(address string, timeout time.Duration, security GRPCSecurity) (PluginCollectorClient, error) {
ctx := context.Background()
p, err := newPluginGrpcClient(ctx, address, timeout, security, plugin.CollectorPluginType)
if err != nil {
return nil, err
}
return p.(PluginCollectorClient), err... | go | {
"resource": ""
} |
q15254 | NewStreamCollectorGrpcClient | train | func NewStreamCollectorGrpcClient(address string, timeout time.Duration, security GRPCSecurity) (PluginStreamCollectorClient, error) {
ctx := context.Background()
p, err := newPluginGrpcClient(ctx, address, timeout, security, plugin.StreamCollectorPluginType)
if err != nil {
return nil, err
}
return p.(PluginStr... | go | {
"resource": ""
} |
q15255 | NewProcessorGrpcClient | train | func NewProcessorGrpcClient(address string, timeout time.Duration, security GRPCSecurity) (PluginProcessorClient, error) {
ctx := context.Background()
p, err := newPluginGrpcClient(ctx, address, timeout, security, plugin.ProcessorPluginType)
if err != nil {
return nil, err
}
return p.(PluginProcessorClient), err... | go | {
"resource": ""
} |
q15256 | NewPublisherGrpcClient | train | func NewPublisherGrpcClient(address string, timeout time.Duration, security GRPCSecurity) (PluginPublisherClient, error) {
ctx := context.Background()
p, err := newPluginGrpcClient(ctx, address, timeout, security, plugin.PublisherPluginType)
if err != nil {
return nil, err
}
return p.(PluginPublisherClient), err... | go | {
"resource": ""
} |
q15257 | newPluginGrpcClient | train | func newPluginGrpcClient(ctx context.Context, address string, timeout time.Duration, security GRPCSecurity, typ plugin.PluginType) (interface{}, error) {
address, port, err := parseAddress(address)
if err != nil {
return nil, err
}
var p *grpcClient
var creds credentials.TransportCredentials
if creds, err = bui... | go | {
"resource": ""
} |
q15258 | GetConfigPolicy | train | func (f *Mock) GetConfigPolicy() (*cpolicy.ConfigPolicy, error) {
c := cpolicy.New()
rule, _ := cpolicy.NewStringRule("name", false, "bob")
rule2, _ := cpolicy.NewStringRule("password", true)
p := cpolicy.NewPolicyNode()
p.Add(rule)
p.Add(rule2)
c.Add([]string{"intel", "mock", "foo"}, p)
return c, nil
} | go | {
"resource": ""
} |
q15259 | beforeAction | train | func beforeAction(ctx *cli.Context) error {
username, password := checkForAuth(ctx)
pClient, err = client.New(ctx.String("url"), ctx.String("api-version"), ctx.Bool("insecure"), client.Timeout(ctx.Duration("timeout")))
if err != nil {
return fmt.Errorf("%v", err)
}
pClient.Password = password
pClient.Username =... | go | {
"resource": ""
} |
q15260 | checkTribeCommand | train | func checkTribeCommand(ctx *cli.Context) error {
tribe := false
for _, a := range os.Args {
for _, command := range tribeCommands {
if strings.Contains(a, command.Name) {
tribe = true
break
}
}
if tribe {
break
}
}
if !tribe {
return nil
}
resp := pClient.ListAgreements()
if resp.Err !... | go | {
"resource": ""
} |
q15261 | Select | train | func (l *lru) Select(aps []AvailablePlugin, _ string) (AvailablePlugin, error) {
t := time.Now()
index := -1
for i, ap := range aps {
// look for the least recently used
if ap.LastHit().Before(t) || index == -1 {
index = i
t = ap.LastHit()
}
}
if index > -1 {
l.logger.WithFields(log.Fields{
"block... | go | {
"resource": ""
} |
q15262 | Remove | train | func (l *lru) Remove(aps []AvailablePlugin, taskID string) (AvailablePlugin, error) {
ap, err := l.Select(aps, taskID)
if err != nil {
return nil, err
}
return ap, nil
} | go | {
"resource": ""
} |
q15263 | ListMembers | train | func (c *Client) ListMembers() *ListMembersResult {
resp, err := c.do("GET", "/tribe/members", ContentTypeJSON, nil)
if err != nil {
return &ListMembersResult{Err: err}
}
switch resp.Meta.Type {
case rbody.TribeMemberListType:
// Success
return &ListMembersResult{resp.Body.(*rbody.TribeMemberList), nil}
cas... | go | {
"resource": ""
} |
q15264 | GetMember | train | func (c *Client) GetMember(name string) *GetMemberResult {
resp, err := c.do("GET", fmt.Sprintf("/tribe/member/%s", name), ContentTypeJSON, nil)
if err != nil {
return &GetMemberResult{Err: err}
}
switch resp.Meta.Type {
case rbody.TribeMemberShowType:
// Success
return &GetMemberResult{resp.Body.(*rbody.Tri... | go | {
"resource": ""
} |
q15265 | ListAgreements | train | func (c *Client) ListAgreements() *ListAgreementResult {
resp, err := c.do("GET", "/tribe/agreements", ContentTypeJSON, nil)
if err != nil {
return &ListAgreementResult{Err: err}
}
switch resp.Meta.Type {
case rbody.TribeListAgreementType:
return &ListAgreementResult{resp.Body.(*rbody.TribeListAgreement), nil}... | go | {
"resource": ""
} |
q15266 | AddAgreement | train | func (c *Client) AddAgreement(name string) *AddAgreementResult {
b, err := json.Marshal(struct {
Name string `json:"name"`
}{Name: name})
if err != nil {
return &AddAgreementResult{Err: err}
}
resp, err := c.do("POST", "/tribe/agreements", ContentTypeJSON, b)
if err != nil {
return &AddAgreementResult{Err: ... | go | {
"resource": ""
} |
q15267 | DeleteAgreement | train | func (c *Client) DeleteAgreement(name string) *DeleteAgreementResult {
resp, err := c.do("DELETE", fmt.Sprintf("/tribe/agreements/%s", name), ContentTypeJSON, nil)
if err != nil {
return &DeleteAgreementResult{Err: err}
}
switch resp.Meta.Type {
case rbody.TribeDeleteAgreementType:
return &DeleteAgreementResul... | go | {
"resource": ""
} |
q15268 | GetAgreement | train | func (c *Client) GetAgreement(name string) *GetAgreementResult {
resp, err := c.do("GET", fmt.Sprintf("/tribe/agreements/%s", name), ContentTypeJSON, nil)
if err != nil {
return &GetAgreementResult{Err: err}
}
switch resp.Meta.Type {
case rbody.TribeGetAgreementType:
return &GetAgreementResult{resp.Body.(*rbod... | go | {
"resource": ""
} |
q15269 | JoinAgreement | train | func (c *Client) JoinAgreement(agreementName, memberName string) *JoinAgreementResult {
b, err := json.Marshal(struct {
MemberName string `json:"member_name"`
}{MemberName: memberName})
if err != nil {
return &JoinAgreementResult{Err: err}
}
resp, err := c.do("PUT", fmt.Sprintf("/tribe/agreements/%s/join", agr... | go | {
"resource": ""
} |
q15270 | LeaveAgreement | train | func (c *Client) LeaveAgreement(agreementName, memberName string) *LeaveAgreementResult {
b, err := json.Marshal(struct {
MemberName string `json:"member_name"`
}{MemberName: memberName})
if err != nil {
return &LeaveAgreementResult{Err: err}
}
resp, err := c.do("DELETE", fmt.Sprintf("/tribe/agreements/%s/leav... | go | {
"resource": ""
} |
q15271 | ToNamespace | train | func ToNamespace(n core.Namespace) []*NamespaceElement {
elements := make([]*NamespaceElement, 0, len(n))
for _, value := range n {
ne := &NamespaceElement{
Value: value.Value,
Description: value.Description,
Name: value.Name,
}
elements = append(elements, ne)
}
return elements
} | go | {
"resource": ""
} |
q15272 | ToCoreMetric | train | func ToCoreMetric(mt *Metric) core.Metric {
var lastAdvertisedTime time.Time
// if the lastAdvertisedTime is not set we handle. -62135596800 represents the
// number of seconds from 0001-1970 and is the default value for time.Unix.
if mt.LastAdvertisedTime.Sec == int64(-62135596800) {
lastAdvertisedTime = time.U... | go | {
"resource": ""
} |
q15273 | ToCoreNamespace | train | func ToCoreNamespace(n []*NamespaceElement) core.Namespace {
var namespace core.Namespace
for _, val := range n {
ele := core.NamespaceElement{
Value: val.Value,
Description: val.Description,
Name: val.Name,
}
namespace = append(namespace, ele)
}
return namespace
} | go | {
"resource": ""
} |
q15274 | ToSubPluginMsg | train | func ToSubPluginMsg(pl core.SubscribedPlugin) *SubscribedPlugin {
return &SubscribedPlugin{
TypeName: pl.TypeName(),
Name: pl.Name(),
Version: int64(pl.Version()),
Config: ConfigToConfigMap(pl.Config()),
}
} | go | {
"resource": ""
} |
q15275 | ToSubPlugin | train | func ToSubPlugin(msg *SubscribedPlugin) core.SubscribedPlugin {
return SubPlugin{
typeName: msg.TypeName,
name: msg.Name,
version: int(msg.Version),
config: ConfigMapToConfig(msg.Config),
}
} | go | {
"resource": ""
} |
q15276 | ToCorePluginMsg | train | func ToCorePluginMsg(pl core.Plugin) *Plugin {
return &Plugin{
TypeName: pl.TypeName(),
Name: pl.Name(),
Version: int64(pl.Version()),
}
} | go | {
"resource": ""
} |
q15277 | ToCorePluginsMsg | train | func ToCorePluginsMsg(pls []core.Plugin) []*Plugin {
plugins := make([]*Plugin, len(pls))
for i, v := range pls {
plugins[i] = ToCorePluginMsg(v)
}
return plugins
} | go | {
"resource": ""
} |
q15278 | MsgToCorePlugin | train | func MsgToCorePlugin(msg *Plugin) core.Plugin {
pl := &SubPlugin{
typeName: msg.TypeName,
name: msg.Name,
version: int(msg.Version),
}
return core.Plugin(pl)
} | go | {
"resource": ""
} |
q15279 | MsgToCorePlugins | train | func MsgToCorePlugins(msg []*Plugin) []core.Plugin {
plugins := make([]core.Plugin, len(msg))
for i, v := range msg {
plugins[i] = MsgToCorePlugin(v)
}
return plugins
} | go | {
"resource": ""
} |
q15280 | ToSubPlugins | train | func ToSubPlugins(msg []*SubscribedPlugin) []core.SubscribedPlugin {
plugins := make([]core.SubscribedPlugin, len(msg))
for i, v := range msg {
plugins[i] = ToSubPlugin(v)
}
return plugins
} | go | {
"resource": ""
} |
q15281 | ToSubPluginsMsg | train | func ToSubPluginsMsg(sp []core.SubscribedPlugin) []*SubscribedPlugin {
plugins := make([]*SubscribedPlugin, len(sp))
for i, v := range sp {
plugins[i] = ToSubPluginMsg(v)
}
return plugins
} | go | {
"resource": ""
} |
q15282 | ConfigMapToConfig | train | func ConfigMapToConfig(cfg *ConfigMap) *cdata.ConfigDataNode {
if cfg == nil {
return nil
}
config := cdata.FromTable(ParseConfig(cfg))
return config
} | go | {
"resource": ""
} |
q15283 | ConfigToConfigMap | train | func ConfigToConfigMap(cd *cdata.ConfigDataNode) *ConfigMap {
if cd == nil {
return nil
}
return ToConfigMap(cd.Table())
} | go | {
"resource": ""
} |
q15284 | ConvertSnapErrors | train | func ConvertSnapErrors(s []*SnapError) []serror.SnapError {
rerrs := make([]serror.SnapError, len(s))
for i, err := range s {
rerrs[i] = serror.New(errors.New(err.ErrorString), GetFields(err))
}
return rerrs
} | go | {
"resource": ""
} |
q15285 | ToSnapError | train | func ToSnapError(e *SnapError) serror.SnapError {
if e == nil {
return nil
}
return serror.New(errors.New(e.ErrorString), GetFields(e))
} | go | {
"resource": ""
} |
q15286 | GetFields | train | func GetFields(s *SnapError) map[string]interface{} {
fields := make(map[string]interface{}, len(s.ErrorFields))
for key, value := range s.ErrorFields {
fields[key] = value
}
return fields
} | go | {
"resource": ""
} |
q15287 | Get | train | func (m *managers) Get(key string) (managesMetrics, error) {
if key == "" {
return m.local, nil
}
m.mutex.RLock()
defer m.mutex.RUnlock()
if val, ok := m.remoteManagers[key]; ok {
return val, nil
} else {
return nil, errors.New(fmt.Sprintf("Client not found for: %v", key))
}
} | go | {
"resource": ""
} |
q15288 | wmapToWorkflow | train | func wmapToWorkflow(wfMap *wmap.WorkflowMap) (*schedulerWorkflow, error) {
wf := &schedulerWorkflow{}
err := convertCollectionNode(wfMap.Collect, wf)
if err != nil {
return nil, err
}
// ***
// TODO validate workflow makes sense here
// - flows that don't end in publishers?
// - duplicate child nodes anywhere... | go | {
"resource": ""
} |
q15289 | Start | train | func (s *schedulerWorkflow) Start(t *task) {
workflowLogger.WithFields(log.Fields{
"_block": "workflow-start",
"task-id": t.id,
"task-name": t.name,
}).Debug("Starting workflow")
s.state = WorkflowStarted
j := newCollectorJob(s.metrics, t.deadlineDuration, t.metricsManager, t.workflow.configTree, t.id, s... | go | {
"resource": ""
} |
q15290 | workJobs | train | func workJobs(prs []*processNode, pus []*publishNode, t *task, pj job) {
// optimize for no jobs
if len(prs) == 0 && len(pus) == 0 {
return
}
// Create waitgroup to block until all jobs are submitted
wg := &sync.WaitGroup{}
workflowLogger.WithFields(log.Fields{
"_block": "work-jobs",
"task-id":... | go | {
"resource": ""
} |
q15291 | GetClientConnection | train | func GetClientConnection(ctx context.Context, addr string, port int) (*grpc.ClientConn, error) {
return GetClientConnectionWithCreds(ctx, addr, port, nil)
} | go | {
"resource": ""
} |
q15292 | IsTLSEnabled | train | func (p *Config) IsTLSEnabled() bool {
if p.TLSCertPath != "" && p.TLSKeyPath != "" {
return true
}
return false
} | go | {
"resource": ""
} |
q15293 | WritePEMFile | train | func (u CertTestUtil) WritePEMFile(fn string, pemHeader string, b []byte) error {
f, err := os.Create(fn)
if err != nil {
return err
}
defer f.Close()
w := bufio.NewWriter(f)
pem.Encode(w, &pem.Block{
Type: pemHeader,
Bytes: b,
})
w.Flush()
return nil
} | go | {
"resource": ""
} |
q15294 | MakeCACertKeyPair | train | func (u CertTestUtil) MakeCACertKeyPair(caName, ouName string, keyValidPeriod time.Duration) (caCertTpl *x509.Certificate, caCertBytes []byte, caPrivKey *rsa.PrivateKey, err error) {
caPrivKey, err = rsa.GenerateKey(rand.Reader, keyBitsDefault)
if err != nil {
return nil, nil, nil, err
}
caPubKey := caPrivKey.Pub... | go | {
"resource": ""
} |
q15295 | MakeSubjCertKeyPair | train | func (u CertTestUtil) MakeSubjCertKeyPair(cn, ou string, keyValidPeriod time.Duration, caCertTpl *x509.Certificate, caPrivKey *rsa.PrivateKey) (subjCertBytes []byte, subjPrivKey *rsa.PrivateKey, err error) {
subjPrivKey, err = rsa.GenerateKey(rand.Reader, keyBitsDefault)
if err != nil {
return nil, nil, err
}
sub... | go | {
"resource": ""
} |
q15296 | GetConfigTree | train | func (c *CollectWorkflowMapNode) GetConfigTree() (*cdata.ConfigDataTree, error) {
cdt := cdata.NewTree()
// Iterate over config and attempt to convert into data nodes in the tree
for ns_, cmap := range c.Config {
ns := strings.Split(ns_, "/")[1:]
cdn, err := configtoConfigDataNode(cmap, ns_)
if err != nil {
... | go | {
"resource": ""
} |
q15297 | mergeCliOptions | train | func (t *task) mergeCliOptions(ctx *cli.Context) error {
// set the name of the task (if a 'name' was provided in the CLI options)
name := ctx.String("name")
if ctx.IsSet("name") || name != "" {
t.Name = name
}
// set the deadline of the task (if a 'deadline' was provided in the CLI options)
deadline := ctx.Str... | go | {
"resource": ""
} |
q15298 | validateSchema | train | func (r *schemaValidatorType) validateSchema(schema, cfg string) []serror.SnapError {
schemaLoader := gojsonschema.NewStringLoader(schema)
testDoc := gojsonschema.NewStringLoader(cfg)
result, err := gojsonschema.Validate(schemaLoader, testDoc)
var serrors []serror.SnapError
// Check for invalid json
if err != nil... | go | {
"resource": ""
} |
q15299 | newTask | train | func newTask(s schedule.Schedule, wf *schedulerWorkflow, m *workManager, mm managesMetrics, emitter gomit.Emitter, opts ...core.TaskOption) (*task, error) {
//Task would always be given a default name.
//However if a user want to change this name, she can pass optional arguments, in form of core.TaskOption
//The ne... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.