_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q27400 | openStore | train | func (m *Main) openStore() error {
// If the advertised address is not in the peer list then we should proxy.
// Resolve advertised address.
addr, err := net.ResolveTCPAddr("tcp", m.advertiseAddr)
if err != nil {
return err
}
// Listen via mux
storeLn := m.mux.Listen([]byte{server.StoreHdr})
// Initialize ... | go | {
"resource": ""
} |
q27401 | openDNSServer | train | func (m *Main) openDNSServer(addr string, recursors []string) error {
s := &server.DNSServer{
UDPAddr: addr,
TCPAddr: addr,
Recursors: recursors,
}
// If store is available then attach it. Otherwise use a proxy.
if m.store != nil {
s.SetStore(m.store)
} else {
s.SetStore(&server.ProxyStore{Peers: m.... | go | {
"resource": ""
} |
q27402 | openHTTPServer | train | func (m *Main) openHTTPServer() error {
h := server.NewHandler(false, m.peers)
h.Main = m
h.Peers = m.peers
// If we have no store then start the handler in proxy mode
if m.store == nil {
h.Proxy.Store(true)
} else {
h.Store = m.store
}
m.handler = h
m.httpServer = &http.Server{Handler: h}
// Create list... | go | {
"resource": ""
} |
q27403 | Notify | train | func (m *Main) Notify(notifyURL, dnsAddr string) {
m.mu.Lock()
m.status.URL = strings.Join(m.peers, ",")
if dnsAddr != "" {
m.status.DNS = dnsAddr
}
payload, _ := json.Marshal(m.status)
m.mu.Unlock()
res, err := http.Post(notifyURL, "application/json", bytes.NewReader(payload))
if err != nil {
m.logger.Pri... | go | {
"resource": ""
} |
q27404 | MergeHostPort | train | func MergeHostPort(host, portAddr string) string {
_, port, _ := net.SplitHostPort(portAddr)
return net.JoinHostPort(host, port)
} | go | {
"resource": ""
} |
q27405 | waitForLeader | train | func (m *Main) waitForLeader(timeout time.Duration) error {
// Ignore leadership if we are a proxy.
if m.store == nil {
return nil
}
var timeoutCh <-chan time.Time
if timeout != IndefiniteTimeout {
timeoutCh = time.After(timeout)
}
for {
select {
case <-timeoutCh:
return errors.New("timed out waiting ... | go | {
"resource": ""
} |
q27406 | TrimSpaceSlice | train | func TrimSpaceSlice(a []string) []string {
other := make([]string, 0, len(a))
for _, s := range a {
s = strings.TrimSpace(s)
if s == "" {
continue
}
other = append(other, s)
}
return other
} | go | {
"resource": ""
} |
q27407 | SetPortSlice | train | func SetPortSlice(peers []string, addr string) ([]string, error) {
// Retrieve the port from addr.
_, port, err := net.SplitHostPort(addr)
if err != nil {
return nil, err
}
// Merge the port with the peer hosts into a new slice.
other := make([]string, len(peers))
for i, peer := range peers {
host, _, err :... | go | {
"resource": ""
} |
q27408 | GetCACert | train | func (c *Client) GetCACert() ([]byte, error) {
var cert bytes.Buffer
res, err := c.RawReq("GET", "/ca-cert", nil, nil, nil)
if err != nil {
return nil, err
}
defer res.Body.Close()
if _, err := io.Copy(&cert, res.Body); err != nil {
return nil, err
}
return cert.Bytes(), nil
} | go | {
"resource": ""
} |
q27409 | PutDomain | train | func (c *Client) PutDomain(dm *ct.DomainMigration) error {
if dm.Domain == "" {
return errors.New("controller: missing domain")
}
if dm.OldDomain == "" {
return errors.New("controller: missing old domain")
}
return c.Put("/domain", dm, dm)
} | go | {
"resource": ""
} |
q27410 | CreateArtifact | train | func (c *Client) CreateArtifact(artifact *ct.Artifact) error {
return c.Post("/artifacts", artifact, artifact)
} | go | {
"resource": ""
} |
q27411 | CreateRelease | train | func (c *Client) CreateRelease(appID string, release *ct.Release) error {
release.AppID = appID
return c.Post("/releases", release, release)
} | go | {
"resource": ""
} |
q27412 | CreateApp | train | func (c *Client) CreateApp(app *ct.App) error {
return c.Post("/apps", app, app)
} | go | {
"resource": ""
} |
q27413 | UpdateApp | train | func (c *Client) UpdateApp(app *ct.App) error {
if app.ID == "" {
return errors.New("controller: missing id")
}
return c.Post(fmt.Sprintf("/apps/%s", app.ID), app, app)
} | go | {
"resource": ""
} |
q27414 | DeleteApp | train | func (c *Client) DeleteApp(appID string) (*ct.AppDeletion, error) {
events := make(chan *ct.Event)
stream, err := c.StreamEvents(ct.StreamEventsOptions{
AppID: appID,
ObjectTypes: []ct.EventType{ct.EventTypeAppDeletion},
}, events)
if err != nil {
return nil, err
}
defer stream.Close()
if err := c.D... | go | {
"resource": ""
} |
q27415 | CreateProvider | train | func (c *Client) CreateProvider(provider *ct.Provider) error {
return c.Post("/providers", provider, provider)
} | go | {
"resource": ""
} |
q27416 | GetProvider | train | func (c *Client) GetProvider(providerID string) (*ct.Provider, error) {
provider := &ct.Provider{}
return provider, c.Get(fmt.Sprintf("/providers/%s", providerID), provider)
} | go | {
"resource": ""
} |
q27417 | ProvisionResource | train | func (c *Client) ProvisionResource(req *ct.ResourceReq) (*ct.Resource, error) {
if req.ProviderID == "" {
return nil, errors.New("controller: missing provider id")
}
res := &ct.Resource{}
err := c.Post(fmt.Sprintf("/providers/%s/resources", req.ProviderID), req, res)
return res, err
} | go | {
"resource": ""
} |
q27418 | GetResource | train | func (c *Client) GetResource(providerID, resourceID string) (*ct.Resource, error) {
res := &ct.Resource{}
err := c.Get(fmt.Sprintf("/providers/%s/resources/%s", providerID, resourceID), res)
return res, err
} | go | {
"resource": ""
} |
q27419 | ResourceListAll | train | func (c *Client) ResourceListAll() ([]*ct.Resource, error) {
var resources []*ct.Resource
return resources, c.Get("/resources", &resources)
} | go | {
"resource": ""
} |
q27420 | ResourceList | train | func (c *Client) ResourceList(providerID string) ([]*ct.Resource, error) {
var resources []*ct.Resource
return resources, c.Get(fmt.Sprintf("/providers/%s/resources", providerID), &resources)
} | go | {
"resource": ""
} |
q27421 | AddResourceApp | train | func (c *Client) AddResourceApp(providerID, resourceID, appID string) (*ct.Resource, error) {
var resource *ct.Resource
return resource, c.Put(fmt.Sprintf("/providers/%s/resources/%s/apps/%s", providerID, resourceID, appID), nil, &resource)
} | go | {
"resource": ""
} |
q27422 | DeleteResourceApp | train | func (c *Client) DeleteResourceApp(providerID, resourceID, appID string) (*ct.Resource, error) {
var resource *ct.Resource
return resource, c.Delete(fmt.Sprintf("/providers/%s/resources/%s/apps/%s", providerID, resourceID, appID), &resource)
} | go | {
"resource": ""
} |
q27423 | AppResourceList | train | func (c *Client) AppResourceList(appID string) ([]*ct.Resource, error) {
var resources []*ct.Resource
return resources, c.Get(fmt.Sprintf("/apps/%s/resources", appID), &resources)
} | go | {
"resource": ""
} |
q27424 | PutResource | train | func (c *Client) PutResource(resource *ct.Resource) error {
if resource.ID == "" || resource.ProviderID == "" {
return errors.New("controller: missing id and/or provider id")
}
return c.Put(fmt.Sprintf("/providers/%s/resources/%s", resource.ProviderID, resource.ID), resource, resource)
} | go | {
"resource": ""
} |
q27425 | DeleteResource | train | func (c *Client) DeleteResource(providerID, resourceID string) (*ct.Resource, error) {
res := &ct.Resource{}
err := c.Delete(fmt.Sprintf("/providers/%s/resources/%s", providerID, resourceID), res)
return res, err
} | go | {
"resource": ""
} |
q27426 | PutFormation | train | func (c *Client) PutFormation(formation *ct.Formation) error {
if formation.AppID == "" || formation.ReleaseID == "" {
return errors.New("controller: missing app id and/or release id")
}
return c.Put(fmt.Sprintf("/apps/%s/formations/%s", formation.AppID, formation.ReleaseID), formation, formation)
} | go | {
"resource": ""
} |
q27427 | PutJob | train | func (c *Client) PutJob(job *ct.Job) error {
if job.UUID == "" || job.AppID == "" {
return errors.New("controller: missing job uuid and/or app id")
}
return c.Put(fmt.Sprintf("/apps/%s/jobs/%s", job.AppID, job.UUID), job, job)
} | go | {
"resource": ""
} |
q27428 | DeleteJob | train | func (c *Client) DeleteJob(appID, jobID string) error {
return c.Delete(fmt.Sprintf("/apps/%s/jobs/%s", appID, jobID), nil)
} | go | {
"resource": ""
} |
q27429 | SetAppRelease | train | func (c *Client) SetAppRelease(appID, releaseID string) error {
return c.Put(fmt.Sprintf("/apps/%s/release", appID), &ct.Release{ID: releaseID}, nil)
} | go | {
"resource": ""
} |
q27430 | GetAppRelease | train | func (c *Client) GetAppRelease(appID string) (*ct.Release, error) {
release := &ct.Release{}
return release, c.Get(fmt.Sprintf("/apps/%s/release", appID), release)
} | go | {
"resource": ""
} |
q27431 | RouteList | train | func (c *Client) RouteList(appID string) ([]*router.Route, error) {
var routes []*router.Route
return routes, c.Get(fmt.Sprintf("/apps/%s/routes", appID), &routes)
} | go | {
"resource": ""
} |
q27432 | GetRoute | train | func (c *Client) GetRoute(appID string, routeID string) (*router.Route, error) {
route := &router.Route{}
return route, c.Get(fmt.Sprintf("/apps/%s/routes/%s", appID, routeID), route)
} | go | {
"resource": ""
} |
q27433 | CreateRoute | train | func (c *Client) CreateRoute(appID string, route *router.Route) error {
return c.Post(fmt.Sprintf("/apps/%s/routes", appID), route, route)
} | go | {
"resource": ""
} |
q27434 | UpdateRoute | train | func (c *Client) UpdateRoute(appID string, routeID string, route *router.Route) error {
return c.Put(fmt.Sprintf("/apps/%s/routes/%s", appID, routeID), route, route)
} | go | {
"resource": ""
} |
q27435 | DeleteRoute | train | func (c *Client) DeleteRoute(appID string, routeID string) error {
return c.Delete(fmt.Sprintf("/apps/%s/routes/%s", appID, routeID), nil)
} | go | {
"resource": ""
} |
q27436 | GetFormation | train | func (c *Client) GetFormation(appID, releaseID string) (*ct.Formation, error) {
formation := &ct.Formation{}
return formation, c.Get(fmt.Sprintf("/apps/%s/formations/%s", appID, releaseID), formation)
} | go | {
"resource": ""
} |
q27437 | GetExpandedFormation | train | func (c *Client) GetExpandedFormation(appID, releaseID string) (*ct.ExpandedFormation, error) {
formation := &ct.ExpandedFormation{}
return formation, c.Get(fmt.Sprintf("/apps/%s/formations/%s?expand=true", appID, releaseID), formation)
} | go | {
"resource": ""
} |
q27438 | FormationList | train | func (c *Client) FormationList(appID string) ([]*ct.Formation, error) {
var formations []*ct.Formation
return formations, c.Get(fmt.Sprintf("/apps/%s/formations", appID), &formations)
} | go | {
"resource": ""
} |
q27439 | DeleteFormation | train | func (c *Client) DeleteFormation(appID, releaseID string) error {
return c.Delete(fmt.Sprintf("/apps/%s/formations/%s", appID, releaseID), nil)
} | go | {
"resource": ""
} |
q27440 | GetRelease | train | func (c *Client) GetRelease(releaseID string) (*ct.Release, error) {
release := &ct.Release{}
return release, c.Get(fmt.Sprintf("/releases/%s", releaseID), release)
} | go | {
"resource": ""
} |
q27441 | GetArtifact | train | func (c *Client) GetArtifact(artifactID string) (*ct.Artifact, error) {
artifact := &ct.Artifact{}
return artifact, c.Get(fmt.Sprintf("/artifacts/%s", artifactID), artifact)
} | go | {
"resource": ""
} |
q27442 | GetApp | train | func (c *Client) GetApp(appID string) (*ct.App, error) {
app := &ct.App{}
return app, c.Get(fmt.Sprintf("/apps/%s", appID), app)
} | go | {
"resource": ""
} |
q27443 | GetAppLog | train | func (c *Client) GetAppLog(appID string, opts *logagg.LogOpts) (io.ReadCloser, error) {
path := fmt.Sprintf("/apps/%s/log", appID)
if opts != nil {
if encodedQuery := opts.EncodedQuery(); encodedQuery != "" {
path = fmt.Sprintf("%s?%s", path, encodedQuery)
}
}
res, err := c.RawReq("GET", path, nil, nil, nil)... | go | {
"resource": ""
} |
q27444 | StreamAppLog | train | func (c *Client) StreamAppLog(appID string, opts *logagg.LogOpts, output chan<- *ct.SSELogChunk) (stream.Stream, error) {
path := fmt.Sprintf("/apps/%s/log", appID)
if opts != nil {
if encodedQuery := opts.EncodedQuery(); encodedQuery != "" {
path = fmt.Sprintf("%s?%s", path, encodedQuery)
}
}
return c.Strea... | go | {
"resource": ""
} |
q27445 | GetDeployment | train | func (c *Client) GetDeployment(deploymentID string) (*ct.Deployment, error) {
res := &ct.Deployment{}
return res, c.Get(fmt.Sprintf("/deployments/%s", deploymentID), res)
} | go | {
"resource": ""
} |
q27446 | DeploymentList | train | func (c *Client) DeploymentList(appID string) ([]*ct.Deployment, error) {
var deployments []*ct.Deployment
return deployments, c.Get(fmt.Sprintf("/apps/%s/deployments", appID), &deployments)
} | go | {
"resource": ""
} |
q27447 | StreamJobEvents | train | func (c *Client) StreamJobEvents(appID string, output chan *ct.Job) (stream.Stream, error) {
appEvents := make(chan *ct.Event)
go convertEvents(appEvents, output)
return c.StreamEvents(ct.StreamEventsOptions{
AppID: appID,
ObjectTypes: []ct.EventType{ct.EventTypeJob},
}, appEvents)
} | go | {
"resource": ""
} |
q27448 | RunJobAttached | train | func (c *Client) RunJobAttached(appID string, job *ct.NewJob) (httpclient.ReadWriteCloser, error) {
return c.Hijack("POST", fmt.Sprintf("/apps/%s/jobs", appID), http.Header{"Upgrade": {"flynn-attach/0"}}, job)
} | go | {
"resource": ""
} |
q27449 | RunJobDetached | train | func (c *Client) RunJobDetached(appID string, req *ct.NewJob) (*ct.Job, error) {
job := &ct.Job{}
return job, c.Post(fmt.Sprintf("/apps/%s/jobs", appID), req, job)
} | go | {
"resource": ""
} |
q27450 | GetJob | train | func (c *Client) GetJob(appID, jobID string) (*ct.Job, error) {
job := &ct.Job{}
return job, c.Get(fmt.Sprintf("/apps/%s/jobs/%s", appID, jobID), job)
} | go | {
"resource": ""
} |
q27451 | JobList | train | func (c *Client) JobList(appID string) ([]*ct.Job, error) {
var jobs []*ct.Job
return jobs, c.Get(fmt.Sprintf("/apps/%s/jobs", appID), &jobs)
} | go | {
"resource": ""
} |
q27452 | JobListActive | train | func (c *Client) JobListActive() ([]*ct.Job, error) {
var jobs []*ct.Job
return jobs, c.Get("/active-jobs", &jobs)
} | go | {
"resource": ""
} |
q27453 | AppList | train | func (c *Client) AppList() ([]*ct.App, error) {
var apps []*ct.App
return apps, c.Get("/apps", &apps)
} | go | {
"resource": ""
} |
q27454 | ArtifactList | train | func (c *Client) ArtifactList() ([]*ct.Artifact, error) {
var artifacts []*ct.Artifact
return artifacts, c.Get("/artifacts", &artifacts)
} | go | {
"resource": ""
} |
q27455 | ReleaseList | train | func (c *Client) ReleaseList() ([]*ct.Release, error) {
var releases []*ct.Release
return releases, c.Get("/releases", &releases)
} | go | {
"resource": ""
} |
q27456 | AppReleaseList | train | func (c *Client) AppReleaseList(appID string) ([]*ct.Release, error) {
var releases []*ct.Release
return releases, c.Get(fmt.Sprintf("/apps/%s/releases", appID), &releases)
} | go | {
"resource": ""
} |
q27457 | ProviderList | train | func (c *Client) ProviderList() ([]*ct.Provider, error) {
var providers []*ct.Provider
return providers, c.Get("/providers", &providers)
} | go | {
"resource": ""
} |
q27458 | GetVolume | train | func (c *Client) GetVolume(appID, id string) (*ct.Volume, error) {
if appID == "" {
return nil, errors.New("controller: missing app ID")
}
if id == "" {
return nil, errors.New("controller: missing id")
}
vol := &ct.Volume{}
return vol, c.Get(fmt.Sprintf("/apps/%s/volumes/%s", appID, id), vol)
} | go | {
"resource": ""
} |
q27459 | PutVolume | train | func (c *Client) PutVolume(vol *ct.Volume) error {
if vol.ID == "" {
return errors.New("controller: missing id")
}
return c.Put(fmt.Sprintf("/volumes/%s", vol.ID), vol, vol)
} | go | {
"resource": ""
} |
q27460 | VolumeList | train | func (c *Client) VolumeList() ([]*ct.Volume, error) {
var volumes []*ct.Volume
return volumes, c.Get("/volumes", &volumes)
} | go | {
"resource": ""
} |
q27461 | AppVolumeList | train | func (c *Client) AppVolumeList(appID string) ([]*ct.Volume, error) {
if appID == "" {
return nil, errors.New("controller: missing app ID")
}
var volumes []*ct.Volume
return volumes, c.Get(fmt.Sprintf("/apps/%s/volumes", appID), &volumes)
} | go | {
"resource": ""
} |
q27462 | DecommissionVolume | train | func (c *Client) DecommissionVolume(appID string, vol *ct.Volume) error {
if appID == "" {
return errors.New("controller: missing app ID")
}
if vol.ID == "" {
return errors.New("controller: missing id")
}
return c.Put(fmt.Sprintf("/apps/%s/volumes/%s/decommission", appID, vol.ID), &vol, &vol)
} | go | {
"resource": ""
} |
q27463 | StreamVolumes | train | func (c *Client) StreamVolumes(since *time.Time, output chan *ct.Volume) (stream.Stream, error) {
if since == nil {
s := time.Unix(0, 0)
since = &s
}
t := since.UTC().Format(time.RFC3339Nano)
return c.Stream("GET", "/volumes?since="+t, nil, output)
} | go | {
"resource": ""
} |
q27464 | Backup | train | func (c *Client) Backup() (io.ReadCloser, error) {
res, err := c.RawReq("GET", "/backup", nil, nil, nil)
if err != nil {
return nil, err
}
return res.Body, nil
} | go | {
"resource": ""
} |
q27465 | GetBackupMeta | train | func (c *Client) GetBackupMeta() (*ct.ClusterBackup, error) {
b := &ct.ClusterBackup{}
return b, c.Get("/backup", b)
} | go | {
"resource": ""
} |
q27466 | DeleteRelease | train | func (c *Client) DeleteRelease(appID, releaseID string) (*ct.ReleaseDeletion, error) {
events := make(chan *ct.Event)
stream, err := c.StreamEvents(ct.StreamEventsOptions{
AppID: appID,
ObjectID: releaseID,
ObjectTypes: []ct.EventType{ct.EventTypeReleaseDeletion},
}, events)
if err != nil {
return ... | go | {
"resource": ""
} |
q27467 | ScheduleAppGarbageCollection | train | func (c *Client) ScheduleAppGarbageCollection(appID string) error {
return c.Post(fmt.Sprintf("/apps/%s/gc", appID), nil, nil)
} | go | {
"resource": ""
} |
q27468 | Status | train | func (c *Client) Status() (*status.Status, error) {
type statusResponse struct {
Data status.Status `json:"data"`
}
s := &statusResponse{}
if err := c.Get(status.Path, s); err != nil {
return nil, err
}
return &s.Data, nil
} | go | {
"resource": ""
} |
q27469 | CreateSink | train | func (c *Client) CreateSink(sink *ct.Sink) error {
return c.Post("/sinks", sink, sink)
} | go | {
"resource": ""
} |
q27470 | GetSink | train | func (c *Client) GetSink(sinkID string) (*ct.Sink, error) {
sink := &ct.Sink{}
return sink, c.Get(fmt.Sprintf("/sinks/%s", sinkID), sink)
} | go | {
"resource": ""
} |
q27471 | DeleteSink | train | func (c *Client) DeleteSink(sinkID string) (*ct.Sink, error) {
sink := &ct.Sink{}
return sink, c.Delete(fmt.Sprintf("/sinks/%s", sinkID), sink)
} | go | {
"resource": ""
} |
q27472 | ListSinks | train | func (c *Client) ListSinks() ([]*ct.Sink, error) {
var sinks []*ct.Sink
return sinks, c.Get("/sinks", &sinks)
} | go | {
"resource": ""
} |
q27473 | addInst | train | func (w *Watch) addInst(inst *Instance) (known, identical bool) {
var i *Instance
i, known = w.instances[inst.ID]
identical = known && i.Equal(inst)
w.instances[inst.ID] = inst
return
} | go | {
"resource": ""
} |
q27474 | delInst | train | func (w *Watch) delInst(inst *Instance) {
delete(w.instances, inst.ID)
} | go | {
"resource": ""
} |
q27475 | maybeStartBlockedJobs | train | func (s *Scheduler) maybeStartBlockedJobs(host *Host) {
for _, job := range s.jobs {
if job.State == JobStateBlocked && job.TagsMatchHost(host) {
job.State = JobStatePending
go s.StartJob(job)
}
}
} | go | {
"resource": ""
} |
q27476 | findVolume | train | func (s *Scheduler) findVolume(job *Job, req *ct.VolumeReq) *Volume {
for _, vol := range s.volumes {
// skip destroyed or decommissioned volumes
if vol.GetState() == ct.VolumeStateDestroyed || vol.DecommissionedAt != nil {
continue
}
// skip if the app, release, type or path do not match
if vol.AppID !=... | go | {
"resource": ""
} |
q27477 | activeFormationCount | train | func (s *Scheduler) activeFormationCount(appID string) int {
activeReleases := make(map[string]struct{})
for _, job := range s.jobs {
if job.IsRunning() && job.IsInApp(appID) {
activeReleases[job.Formation.Release.ID] = struct{}{}
}
}
return len(activeReleases)
} | go | {
"resource": ""
} |
q27478 | findJobToStop | train | func (s *Scheduler) findJobToStop(f *Formation, typ string) (*Job, error) {
var found *Job
for _, job := range s.jobs.WithFormationAndType(f, typ) {
switch job.State {
case JobStatePending:
return job, nil
case JobStateStarting, JobStateRunning:
// if the job is on a host which is shutting down,
// ret... | go | {
"resource": ""
} |
q27479 | readID | train | func (m *Main) readID(path string) (string, error) {
buf, err := ioutil.ReadFile(path)
if err != nil && !os.IsNotExist(err) {
return "", fmt.Errorf("error reading instance ID: %s", err)
}
// If the ID exists then return it immediately.
id := string(buf)
if id != "" {
return id, nil
}
// Generate a new ID ... | go | {
"resource": ""
} |
q27480 | FindAppReleaseJobs | train | func (f *ClusterFixer) FindAppReleaseJobs(app, typ string) []map[string]*host.Job {
var sortReleases ReleasesByCreate
releases := make(map[string]map[string]*host.ActiveJob) // map of releaseID -> hostID -> job ordered
// connect to each host, list jobs, find distinct releases
for _, h := range f.hosts {
jobs, er... | go | {
"resource": ""
} |
q27481 | IsOriginAllowed | train | func (o *Options) IsOriginAllowed(origin string, req *http.Request) (allowed bool) {
if o.ShouldAllowOrigin != nil {
return o.ShouldAllowOrigin(origin, req)
}
for _, pattern := range allowOriginPatterns {
allowed, _ = regexp.MatchString(pattern, origin)
if allowed {
return
}
}
return
} | go | {
"resource": ""
} |
q27482 | Handler | train | func (o *Options) Handler(next http.Handler) http.HandlerFunc {
// Allow default headers if nothing is specified.
if len(o.AllowHeaders) == 0 {
o.AllowHeaders = defaultAllowHeaders
}
for _, origin := range o.AllowOrigins {
pattern := regexp.QuoteMeta(origin)
pattern = strings.Replace(pattern, "\\*", ".*", -1... | go | {
"resource": ""
} |
q27483 | initDB | train | func (p *Process) initDB() error {
log := p.log.New("fn", "initDB", "dir", p.dataDir)
log.Debug("starting initDB")
// ignore errors, since the db could be already initialized
// TODO(titanous): check errors when this is not the case
_ = p.runCmd(exec.Command(
p.binPath("initdb"),
"--pgdata", p.dataDir,
"--u... | go | {
"resource": ""
} |
q27484 | DownloadConfig | train | func (d *Downloader) DownloadConfig(dir string) (map[string]string, error) {
if err := os.MkdirAll(dir, 0755); err != nil {
return nil, fmt.Errorf("error creating config dir: %s", err)
}
paths := make(map[string]string, len(config))
for _, conf := range config {
path, err := d.downloadGzippedFile(conf, dir, fal... | go | {
"resource": ""
} |
q27485 | ExtractHostID | train | func ExtractHostID(id string) (string, error) {
ids := strings.SplitN(id, "-", 2)
if len(ids) != 2 || ids[0] == "" || ids[1] == "" {
return "", errors.New("invalid ID")
}
return ids[0], nil
} | go | {
"resource": ""
} |
q27486 | GenerateJobID | train | func GenerateJobID(hostID, uuid string) string {
if uuid == "" {
uuid = random.UUID()
}
return hostID + "-" + uuid
} | go | {
"resource": ""
} |
q27487 | waitForSync | train | func (p *Process) waitForSync(downstream *discoverd.Instance) {
p.Logger.Debug("waiting for downstream sync")
stopCh := make(chan struct{})
doneCh := make(chan struct{})
var once sync.Once
p.cancelSyncWait = func() {
once.Do(func() { close(stopCh); <-doneCh })
}
go p.waitForSyncInner(downstream, stopCh, don... | go | {
"resource": ""
} |
q27488 | DialInfo | train | func (p *Process) DialInfo() *mgo.DialInfo {
localhost := net.JoinHostPort("localhost", p.Port)
info := &mgo.DialInfo{
Addrs: []string{localhost},
Timeout: 5 * time.Second,
Direct: true,
}
if p.securityEnabled() {
info.Addrs = []string{p.addr()}
info.Database = "admin"
info.Username = "flynn"
info... | go | {
"resource": ""
} |
q27489 | Read | train | func (p *conn) Read(b []byte) (int, error) {
var err error
p.initOnce.Do(func() { err = p.checkPrefix() })
if err != nil {
return 0, err
}
if p.connBuf != nil {
n := copy(b, p.connBuf)
p.connBuf = p.connBuf[n:]
if len(p.connBuf) == 0 {
p.connBuf = nil
}
if len(b) == n {
return n, nil
}
readN,... | go | {
"resource": ""
} |
q27490 | NewAggregator | train | func NewAggregator() *Aggregator {
a := &Aggregator{
buffers: make(map[string]*buffer.Buffer),
msgc: make(chan *rfc5424.Message, 1000),
pausec: make(chan struct{}),
}
go a.run()
return a
} | go | {
"resource": ""
} |
q27491 | Read | train | func (a *Aggregator) Read(id string) []*rfc5424.Message {
return a.getBuffer(id).Read()
} | go | {
"resource": ""
} |
q27492 | ReadAll | train | func (a *Aggregator) ReadAll() [][]*rfc5424.Message {
// TODO(benburkert): restructure Aggregator & ring.Buffer to avoid nested locks
a.bmu.Lock()
defer a.bmu.Unlock()
buffers := make([][]*rfc5424.Message, 0, len(a.buffers))
for _, buf := range a.buffers {
buffers = append(buffers, buf.Read())
}
return buffe... | go | {
"resource": ""
} |
q27493 | ReadAndSubscribe | train | func (a *Aggregator) ReadAndSubscribe(id string, msgc chan<- *rfc5424.Message, donec <-chan struct{}) []*rfc5424.Message {
return a.getBuffer(id).ReadAndSubscribe(msgc, donec)
} | go | {
"resource": ""
} |
q27494 | Reset | train | func (a *Aggregator) Reset() {
a.bmu.Lock()
defer a.bmu.Unlock()
for k, buf := range a.buffers {
buf.Close()
delete(a.buffers, k)
}
} | go | {
"resource": ""
} |
q27495 | Subscribe | train | func (a *Aggregator) Subscribe(id string, msgc chan<- *rfc5424.Message, donec <-chan struct{}) {
a.getBuffer(id).Subscribe(msgc, donec)
} | go | {
"resource": ""
} |
q27496 | pktLine | train | func pktLine(w io.Writer, s string) error {
_, err := fmt.Fprintf(w, "%04x%s", len(s)+4, s)
return err
} | go | {
"resource": ""
} |
q27497 | NewHandler | train | func NewHandler() *Handler {
h := &Handler{
router: httprouter.New(),
Logger: log15.New(),
}
h.router.POST("/clusters", h.servePostCluster)
h.router.DELETE("/clusters", h.serveDeleteCluster)
h.router.GET("/ping", h.serveGetPing)
return h
} | go | {
"resource": ""
} |
q27498 | NewHost | train | func NewHost(id string, addr string, h *http.Client, tags map[string]string) *Host {
if h == nil {
h = http.DefaultClient
}
if !strings.HasPrefix(addr, "http") {
addr = "http://" + addr
}
return &Host{
id: id,
tags: tags,
c: &httpclient.Client{
ErrNotFound: ErrNotFound,
URL: addr,
HTTP... | go | {
"resource": ""
} |
q27499 | ListJobs | train | func (c *Host) ListJobs() (map[string]host.ActiveJob, error) {
var jobs map[string]host.ActiveJob
err := c.c.Get("/host/jobs", &jobs)
return jobs, err
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.