_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q26200 | GetIsolationSegmentOrganizations | train | func (client *Client) GetIsolationSegmentOrganizations(isolationSegmentGUID string) ([]Organization, Warnings, error) {
request, err := client.newHTTPRequest(requestOptions{
RequestName: internal.GetIsolationSegmentOrganizationsRequest,
URIParams: map[string]string{"isolation_segment_guid": isolationSegmentGUID}... | go | {
"resource": ""
} |
q26201 | GetOrganizations | train | func (client *Client) GetOrganizations(query ...Query) ([]Organization, Warnings, error) {
request, err := client.newHTTPRequest(requestOptions{
RequestName: internal.GetOrganizationsRequest,
Query: query,
})
if err != nil {
return nil, nil, err
}
var fullOrgsList []Organization
warnings, err := clie... | go | {
"resource": ""
} |
q26202 | GetApplicationDropletCurrent | train | func (client *Client) GetApplicationDropletCurrent(appGUID string) (Droplet, Warnings, error) {
request, err := client.newHTTPRequest(requestOptions{
RequestName: internal.GetApplicationDropletCurrentRequest,
URIParams: map[string]string{"app_guid": appGUID},
})
if err != nil {
return Droplet{}, nil, err
}
... | go | {
"resource": ""
} |
q26203 | GetDroplet | train | func (client *Client) GetDroplet(dropletGUID string) (Droplet, Warnings, error) {
request, err := client.newHTTPRequest(requestOptions{
RequestName: internal.GetDropletRequest,
URIParams: map[string]string{"droplet_guid": dropletGUID},
})
if err != nil {
return Droplet{}, nil, err
}
var responseDroplet Dr... | go | {
"resource": ""
} |
q26204 | GetDroplets | train | func (client *Client) GetDroplets(query ...Query) ([]Droplet, Warnings, error) {
request, err := client.newHTTPRequest(requestOptions{
RequestName: internal.GetDropletsRequest,
Query: query,
})
if err != nil {
return nil, nil, err
}
var responseDroplets []Droplet
warnings, err := client.paginate(requ... | go | {
"resource": ""
} |
q26205 | IsValidValue | train | func (n *NullInt) IsValidValue(val string) error {
_, err := strconv.Atoi(val)
return err
} | go | {
"resource": ""
} |
q26206 | GetServiceInstances | train | func (client *Client) GetServiceInstances(query ...Query) ([]ServiceInstance, Warnings, error) {
request, err := client.newHTTPRequest(requestOptions{
RequestName: internal.GetServiceInstancesRequest,
Query: query,
})
if err != nil {
return nil, nil, err
}
var fullServiceInstanceList []ServiceInstance... | go | {
"resource": ""
} |
q26207 | UnmarshalJSON | train | func (routeMapping *RouteMapping) UnmarshalJSON(data []byte) error {
var ccRouteMapping struct {
Metadata internal.Metadata `json:"metadata"`
Entity struct {
AppGUID string `json:"app_guid"`
RouteGUID string `json:"route_guid"`
} `json:"entity"`
}
err := cloudcontroller.DecodeJSON(data, &ccRouteMapp... | go | {
"resource": ""
} |
q26208 | GetRouteMapping | train | func (client *Client) GetRouteMapping(guid string) (RouteMapping, Warnings, error) {
request, err := client.newHTTPRequest(requestOptions{
RequestName: internal.GetRouteMappingRequest,
URIParams: Params{"route_mapping_guid": guid},
})
if err != nil {
return RouteMapping{}, nil, err
}
var routeMapping Rout... | go | {
"resource": ""
} |
q26209 | GetRouteMappings | train | func (client *Client) GetRouteMappings(filters ...Filter) ([]RouteMapping, Warnings, error) {
request, err := client.newHTTPRequest(requestOptions{
RequestName: internal.GetRouteMappingsRequest,
Query: ConvertFilterParameters(filters),
})
if err != nil {
return nil, nil, err
}
var fullRouteMappingsLis... | go | {
"resource": ""
} |
q26210 | AuthorizationToken | train | func (refreshTokenResponse RefreshedTokens) AuthorizationToken() string {
return fmt.Sprintf("%s %s", refreshTokenResponse.Type, refreshTokenResponse.AccessToken)
} | go | {
"resource": ""
} |
q26211 | RefreshAccessToken | train | func (client *Client) RefreshAccessToken(refreshToken string) (RefreshedTokens, error) {
var values url.Values
switch client.config.UAAGrantType() {
case string(constant.GrantTypeClientCredentials):
values = client.clientCredentialRefreshBody()
case "", string(constant.GrantTypePassword): // CLI used to write em... | go | {
"resource": ""
} |
q26212 | DisplayKeyValueTable | train | func (ui *UI) DisplayKeyValueTable(prefix string, table [][]string, padding int) {
rows := len(table)
if rows == 0 {
return
}
var displayTable [][]string
for _, row := range table {
if len(row) > 0 {
displayTable = append(displayTable, row)
}
}
columns := len(displayTable[0])
if columns < 2 || !ui.Is... | go | {
"resource": ""
} |
q26213 | DisplayNonWrappingTable | train | func (ui *UI) DisplayNonWrappingTable(prefix string, table [][]string, padding int) {
ui.terminalLock.Lock()
defer ui.terminalLock.Unlock()
if len(table) == 0 {
return
}
var columnPadding []int
rows := len(table)
columns := len(table[0])
for col := 0; col < columns; col++ {
var max int
for row := 0; ro... | go | {
"resource": ""
} |
q26214 | DisplayTableWithHeader | train | func (ui *UI) DisplayTableWithHeader(prefix string, table [][]string, padding int) {
if len(table) == 0 {
return
}
for i, str := range table[0] {
table[0][i] = ui.modifyColor(str, color.New(color.Bold))
}
ui.DisplayNonWrappingTable(prefix, table, padding)
} | go | {
"resource": ""
} |
q26215 | GetApplicationApplicationInstances | train | func (client *Client) GetApplicationApplicationInstances(guid string) (map[int]ApplicationInstance, Warnings, error) {
request, err := client.newHTTPRequest(requestOptions{
RequestName: internal.GetAppInstancesRequest,
URIParams: Params{"app_guid": guid},
})
if err != nil {
return nil, nil, err
}
var inst... | go | {
"resource": ""
} |
q26216 | UnmarshalJSON | train | func (servicePlanVisibility *ServicePlanVisibility) UnmarshalJSON(data []byte) error {
var ccServicePlanVisibility struct {
Metadata internal.Metadata
Entity struct {
ServicePlanGUID string `json:"service_plan_guid"`
OrganizationGUID string `json:"organization_guid"`
} `json:"entity"`
}
err := cloudco... | go | {
"resource": ""
} |
q26217 | GetServicePlanVisibilities | train | func (client *Client) GetServicePlanVisibilities(filters ...Filter) ([]ServicePlanVisibility, Warnings, error) {
request, err := client.newHTTPRequest(requestOptions{
RequestName: internal.GetServicePlanVisibilitiesRequest,
Query: ConvertFilterParameters(filters),
})
if err != nil {
return nil, nil, err... | go | {
"resource": ""
} |
q26218 | Make | train | func (logger *RequestLogger) Make(request *http.Request, passedResponse *uaa.Response) error {
err := logger.displayRequest(request)
if err != nil {
logger.output.HandleInternalError(err)
}
err = logger.connection.Make(request, passedResponse)
if passedResponse.HTTPResponse != nil {
displayErr := logger.disp... | go | {
"resource": ""
} |
q26219 | UnmarshalJSON | train | func (spaceQuota *SpaceQuota) UnmarshalJSON(data []byte) error {
var ccSpaceQuota struct {
Metadata internal.Metadata `json:"metadata"`
Entity struct {
Name string `json:"name"`
} `json:"entity"`
}
err := cloudcontroller.DecodeJSON(data, &ccSpaceQuota)
if err != nil {
return err
}
spaceQuota.GUID = ... | go | {
"resource": ""
} |
q26220 | GetSpaceQuotaDefinition | train | func (client *Client) GetSpaceQuotaDefinition(guid string) (SpaceQuota, Warnings, error) {
request, err := client.newHTTPRequest(requestOptions{
RequestName: internal.GetSpaceQuotaDefinitionRequest,
URIParams: Params{"space_quota_guid": guid},
})
if err != nil {
return SpaceQuota{}, nil, err
}
var spaceQu... | go | {
"resource": ""
} |
q26221 | GetSpaceQuotas | train | func (client *Client) GetSpaceQuotas(orgGUID string) ([]SpaceQuota, Warnings, error) {
request, err := client.newHTTPRequest(requestOptions{
RequestName: internal.GetOrganizationSpaceQuotasRequest,
URIParams: Params{"organization_guid": orgGUID},
})
if err != nil {
return nil, nil, err
}
var spaceQuotas ... | go | {
"resource": ""
} |
q26222 | SetSpaceQuota | train | func (client *Client) SetSpaceQuota(spaceGUID string, quotaGUID string) (Warnings, error) {
request, err := client.newHTTPRequest(requestOptions{
RequestName: internal.PutSpaceQuotaRequest,
URIParams: Params{"space_quota_guid": quotaGUID, "space_guid": spaceGUID},
})
if err != nil {
return nil, err
}
res... | go | {
"resource": ""
} |
q26223 | GetOrganization | train | func (actor Actor) GetOrganization(guid string) (Organization, Warnings, error) {
org, warnings, err := actor.CloudControllerClient.GetOrganization(guid)
if _, ok := err.(ccerror.ResourceNotFoundError); ok {
return Organization{}, Warnings(warnings), actionerror.OrganizationNotFoundError{GUID: guid}
}
return Or... | go | {
"resource": ""
} |
q26224 | GetOrganizationByName | train | func (actor Actor) GetOrganizationByName(orgName string) (Organization, Warnings, error) {
orgs, warnings, err := actor.CloudControllerClient.GetOrganizations(ccv2.Filter{
Type: constant.NameFilter,
Operator: constant.EqualOperator,
Values: []string{orgName},
})
if err != nil {
return Organization{}, W... | go | {
"resource": ""
} |
q26225 | GrantOrgManagerByUsername | train | func (actor Actor) GrantOrgManagerByUsername(guid string, username string) (Warnings, error) {
var warnings ccv2.Warnings
var err error
if actor.Config.UAAGrantType() != string(uaaconst.GrantTypeClientCredentials) {
warnings, err = actor.CloudControllerClient.UpdateOrganizationManagerByUsername(guid, username)
}... | go | {
"resource": ""
} |
q26226 | CreateOrganization | train | func (actor Actor) CreateOrganization(orgName string, quotaName string) (Organization, Warnings, error) {
var quotaGUID string
var allWarnings Warnings
if quotaName != "" {
quota, warnings, err := actor.GetOrganizationQuotaByName(quotaName)
allWarnings = append(allWarnings, warnings...)
if err != nil {
re... | go | {
"resource": ""
} |
q26227 | DeleteOrganization | train | func (actor Actor) DeleteOrganization(orgName string) (Warnings, error) {
var allWarnings Warnings
org, warnings, err := actor.GetOrganizationByName(orgName)
allWarnings = append(allWarnings, warnings...)
if err != nil {
return allWarnings, err
}
job, deleteWarnings, err := actor.CloudControllerClient.DeleteO... | go | {
"resource": ""
} |
q26228 | GetOrganizations | train | func (actor Actor) GetOrganizations() ([]Organization, Warnings, error) {
var returnedOrgs []Organization
orgs, warnings, err := actor.CloudControllerClient.GetOrganizations()
for _, org := range orgs {
returnedOrgs = append(returnedOrgs, Organization(org))
}
return returnedOrgs, Warnings(warnings), err
} | go | {
"resource": ""
} |
q26229 | OrganizationExistsWithName | train | func (actor Actor) OrganizationExistsWithName(orgName string) (bool, Warnings, error) {
orgs, warnings, err := actor.CloudControllerClient.GetOrganizations(ccv2.Filter{
Type: constant.NameFilter,
Operator: constant.EqualOperator,
Values: []string{orgName},
})
if err != nil {
return false, Warnings(warn... | go | {
"resource": ""
} |
q26230 | call | train | func (nc *nccClient) call(name string, in interface{}, out interface{}) error {
nc.lock.RLock()
client := nc.client
nc.lock.RUnlock()
if client == nil {
return fmt.Errorf("Not connected")
}
ch := make(chan error, 1)
go func() {
ch <- client.Call(name, in, out)
}()
select {
case err := <-ch:
return err
... | go | {
"resource": ""
} |
q26231 | String | train | func (s State) String() string {
if name, ok := stateNames[s]; ok {
return name
}
return "<unknown>"
} | go | {
"resource": ""
} |
q26232 | String | train | func (t Target) String() string {
var via string
if t.Mode == seesaw.HCModeDSR {
via = fmt.Sprintf(" (via %s mark %d)", t.Host, t.Mark)
}
return fmt.Sprintf("%s %s%s", t.addr(), t.Mode, via)
} | go | {
"resource": ""
} |
q26233 | addr | train | func (t *Target) addr() string {
if t.IP.To4() != nil {
return fmt.Sprintf("%v:%d", t.IP, t.Port)
}
return fmt.Sprintf("[%v]:%d", t.IP, t.Port)
} | go | {
"resource": ""
} |
q26234 | network | train | func (t *Target) network() string {
version := 4
if t.IP.To4() == nil {
version = 6
}
var network string
switch t.Proto {
case seesaw.IPProtoICMP:
network = "ip4:icmp"
case seesaw.IPProtoICMPv6:
network = "ip6:ipv6-icmp"
case seesaw.IPProtoTCP:
network = fmt.Sprintf("tcp%d", version)
case seesaw.IPPro... | go | {
"resource": ""
} |
q26235 | String | train | func (r *Result) String() string {
if r.Err != nil {
return r.Err.Error()
}
return r.Message
} | go | {
"resource": ""
} |
q26236 | complete | train | func complete(start time.Time, msg string, success bool, err error) *Result {
// TODO(jsing): Make this clock skew safe.
duration := time.Since(start)
return &Result{msg, success, duration, err}
} | go | {
"resource": ""
} |
q26237 | String | train | func (n *Notification) String() string {
return fmt.Sprintf("ID 0x%x %v", n.Id, n.State)
} | go | {
"resource": ""
} |
q26238 | NewConfig | train | func NewConfig(id Id, checker Checker) *Config {
return &Config{
Id: id,
Interval: 5 * time.Second,
Timeout: 30 * time.Second,
Retries: 0,
Checker: checker,
}
} | go | {
"resource": ""
} |
q26239 | NewCheck | train | func NewCheck(notify chan<- *Notification) *Check {
return &Check{
state: StateUnknown,
notify: notify,
update: make(chan Config, 1),
quit: make(chan bool, 1),
}
} | go | {
"resource": ""
} |
q26240 | Status | train | func (hc *Check) Status() Status {
hc.lock.RLock()
defer hc.lock.RUnlock()
status := Status{
LastCheck: hc.start,
Failures: hc.failures,
Successes: hc.successes,
State: hc.state,
}
if hc.result != nil {
status.Duration = hc.result.Duration
status.Message = hc.result.String()
}
return status
} | go | {
"resource": ""
} |
q26241 | Run | train | func (hc *Check) Run(start <-chan time.Time) {
// Wait for initial configuration.
select {
case config := <-hc.update:
hc.Config = config
case <-hc.quit:
return
}
// Wait for a tick to avoid a thundering herd at startup and to
// stagger healthchecks that have the same interval.
if start != nil {
<-star... | go | {
"resource": ""
} |
q26242 | healthcheck | train | func (hc *Check) healthcheck() {
if hc.Checker == nil {
return
}
start := time.Now()
result := hc.execute()
status := "SUCCESS"
if !result.Success {
status = "FAILURE"
}
log.Infof("%d: (%s) %s: %v", hc.Id, hc, status, result)
hc.lock.Lock()
hc.start = start
hc.result = result
var state State
if res... | go | {
"resource": ""
} |
q26243 | Notify | train | func (hc *Check) Notify() {
hc.notify <- &Notification{
Id: hc.Id,
Status: hc.Status(),
}
} | go | {
"resource": ""
} |
q26244 | execute | train | func (hc *Check) execute() *Result {
ch := make(chan *Result, 1)
checker := hc.Checker
go func() {
// TODO(jsing): Determine a way to ensure that this go routine
// does not linger.
ch <- checker.Check(hc.Timeout)
}()
select {
case result := <-ch:
return result
case <-time.After(hc.Timeout):
return &Re... | go | {
"resource": ""
} |
q26245 | Blocking | train | func (hc *Check) Blocking(block bool) {
len := 0
if !block {
len = 1
}
hc.blocking = block
hc.update = make(chan Config, len)
} | go | {
"resource": ""
} |
q26246 | Update | train | func (hc *Check) Update(config *Config) {
if hc.blocking {
hc.update <- *config
return
}
select {
case hc.update <- *config:
default:
log.Warningf("Unable to update %d (%s), last update still queued", hc.Id, hc)
}
} | go | {
"resource": ""
} |
q26247 | NewServer | train | func NewServer(cfg *ServerConfig) *Server {
if cfg == nil {
defaultCfg := DefaultServerConfig()
cfg = &defaultCfg
}
return &Server{
config: cfg,
healthchecks: make(map[Id]*Check),
notify: make(chan *Notification, cfg.ChannelSize),
configs: make(chan map[Id]*Config),
batch: make([]*No... | go | {
"resource": ""
} |
q26248 | Run | train | func (s *Server) Run() {
go s.updater()
go s.notifier()
go s.manager()
<-s.quit
} | go | {
"resource": ""
} |
q26249 | getHealthchecks | train | func (s *Server) getHealthchecks() (*Checks, error) {
engineConn, err := net.DialTimeout("unix", s.config.EngineSocket, engineTimeout)
if err != nil {
return nil, fmt.Errorf("Dial failed: %v", err)
}
engineConn.SetDeadline(time.Now().Add(engineTimeout))
engine := rpc.NewClient(engineConn)
defer engine.Close()
... | go | {
"resource": ""
} |
q26250 | updater | train | func (s *Server) updater() {
for {
log.Info("Getting healthchecks from engine...")
checks, err := s.getHealthchecks()
if err != nil {
log.Error(err)
time.Sleep(5 * time.Second)
} else {
log.Infof("Engine returned %d healthchecks", len(checks.Configs))
s.configs <- checks.Configs
time.Sleep(15 * ... | go | {
"resource": ""
} |
q26251 | manager | train | func (s *Server) manager() {
checkTicker := time.NewTicker(50 * time.Millisecond)
notifyTicker := time.NewTicker(s.config.NotifyInterval)
for {
select {
case configs := <-s.configs:
// Remove healthchecks that have been deleted.
for id, hc := range s.healthchecks {
if configs[id] == nil {
hc.Stop... | go | {
"resource": ""
} |
q26252 | notifier | train | func (s *Server) notifier() {
var timer <-chan time.Time
for {
var err error
select {
case notification := <-s.notify:
s.batch = append(s.batch, notification)
// Collect until BatchDelay passes, or BatchSize are queued.
switch len(s.batch) {
case 1:
timer = time.After(s.config.BatchDelay)
cas... | go | {
"resource": ""
} |
q26253 | send | train | func (s *Server) send() error {
failures := 0
for {
err := s.sendBatch(s.batch)
if err == nil {
break
}
failures++
log.Errorf("Send failed %d times: %v", failures, err)
if failures >= s.config.MaxFailures {
return fmt.Errorf("send: %d errors, giving up", failures)
}
time.Sleep(s.config.RetryDe... | go | {
"resource": ""
} |
q26254 | sendBatch | train | func (s *Server) sendBatch(batch []*Notification) error {
engineConn, err := net.DialTimeout("unix", s.config.EngineSocket, engineTimeout)
if err != nil {
return err
}
engineConn.SetDeadline(time.Now().Add(engineTimeout))
engine := rpc.NewClient(engineConn)
defer engine.Close()
var reply int
ctx := ipc.NewTr... | go | {
"resource": ""
} |
q26255 | newECUStats | train | func newECUStats(ecu *ECU) *ecuStats {
return &ecuStats{
ecu: ecu,
stats: &stats{
lastUpdate: time.Unix(0, 0),
lastSuccess: time.Unix(0, 0),
},
}
} | go | {
"resource": ""
} |
q26256 | notify | train | func (e *ecuStats) notify(p publisher) {
e.publishers = append(e.publishers, p)
} | go | {
"resource": ""
} |
q26257 | run | train | func (e *ecuStats) run() {
ticker := time.NewTicker(e.ecu.cfg.UpdateInterval)
for {
e.stats.lock.Lock()
e.stats.lastUpdate = time.Now()
e.stats.lock.Unlock()
log.Info("Updating ECU statistics from Seesaw Engine...")
if err := e.update(); err != nil {
log.Warning(err)
} else {
e.stats.lock.Lock()
... | go | {
"resource": ""
} |
q26258 | update | train | func (e *ecuStats) update() error {
// TODO(jsing): Make this untrusted.
ctx := ipc.NewTrustedContext(seesaw.SCECU)
seesawConn, err := conn.NewSeesawIPC(ctx)
if err != nil {
return fmt.Errorf("Failed to connect to engine: %v", err)
}
if err := seesawConn.Dial(e.ecu.cfg.EngineSocket); err != nil {
return fmt.E... | go | {
"resource": ""
} |
q26259 | newHealthcheckManager | train | func newHealthcheckManager(e *Engine) *healthcheckManager {
return &healthcheckManager{
engine: e,
marks: make(map[seesaw.IP]uint32),
markAlloc: newMarkAllocator(dsrMarkBase, dsrMarkSize),
ncc: ncclient.NewNCC(e.config.NCCSocket),
next: healthcheck.Id((uint64(os.Getpid()... | go | {
"resource": ""
} |
q26260 | configs | train | func (h *healthcheckManager) configs() map[healthcheck.Id]*healthcheck.Config {
h.lock.RLock()
defer h.lock.RUnlock()
if !h.enabled {
return nil
}
return h.cfgs
} | go | {
"resource": ""
} |
q26261 | update | train | func (h *healthcheckManager) update(vserverName string, checks map[checkKey]*check) {
if checks == nil {
delete(h.vserverChecks, vserverName)
} else {
h.vserverChecks[vserverName] = checks
}
h.buildMaps()
} | go | {
"resource": ""
} |
q26262 | enable | train | func (h *healthcheckManager) enable() {
h.lock.Lock()
defer h.lock.Unlock()
h.enabled = true
} | go | {
"resource": ""
} |
q26263 | disable | train | func (h *healthcheckManager) disable() {
h.lock.Lock()
defer h.lock.Unlock()
h.enabled = false
} | go | {
"resource": ""
} |
q26264 | buildMaps | train | func (h *healthcheckManager) buildMaps() {
allChecks := make(map[checkKey]*check)
for _, vchecks := range h.vserverChecks {
for k, c := range vchecks {
if allChecks[k] == nil {
allChecks[k] = c
} else {
log.Warningf("Duplicate key: %v", k)
}
}
}
h.lock.RLock()
ids := h.ids
cfgs := h.cfgs
ch... | go | {
"resource": ""
} |
q26265 | healthState | train | func (h *healthcheckManager) healthState(n *healthcheck.Notification) error {
log.V(1).Infof("Received healthcheck notification: %v", n)
h.lock.RLock()
enabled := h.enabled
h.lock.RUnlock()
if !enabled {
log.Warningf("Healthcheck manager is disabled; ignoring healthcheck notification %v", n)
return nil
}
... | go | {
"resource": ""
} |
q26266 | queueHealthState | train | func (h *healthcheckManager) queueHealthState(n *healthcheck.Notification) error {
h.lock.RLock()
cfg := h.cfgs[n.Id]
check := h.checks[n.Id]
h.lock.RUnlock()
if cfg == nil || check == nil {
log.Warningf("Unknown healthcheck ID %v", n.Id)
return nil
}
note := &checkNotification{
key: check.key,
... | go | {
"resource": ""
} |
q26267 | run | train | func (h *healthcheckManager) run() {
for {
select {
case <-h.quit:
h.unmarkAllBackends()
h.stopped <- true
case vc := <-h.vcc:
h.update(vc.vserverName, vc.checks)
}
}
} | go | {
"resource": ""
} |
q26268 | expire | train | func (h *healthcheckManager) expire() {
h.lock.RLock()
ids := h.ids
h.lock.RUnlock()
status := healthcheck.Status{State: healthcheck.StateUnknown}
for _, id := range ids {
h.queueHealthState(&healthcheck.Notification{id, status})
}
} | go | {
"resource": ""
} |
q26269 | markBackend | train | func (h *healthcheckManager) markBackend(backend seesaw.IP) uint32 {
mark, ok := h.marks[backend]
if ok {
return mark
}
mark, err := h.markAlloc.get()
if err != nil {
log.Fatalf("Failed to get mark: %v", err)
}
h.marks[backend] = mark
ip := net.IPv6zero
if backend.AF() == seesaw.IPv4 {
ip = net.IPv4zer... | go | {
"resource": ""
} |
q26270 | pruneMarks | train | func (h *healthcheckManager) pruneMarks() {
h.lock.RLock()
checks := h.checks
h.lock.RUnlock()
backends := make(map[seesaw.IP]bool)
for _, check := range checks {
if check.key.healthcheckMode != seesaw.HCModeDSR {
continue
}
backends[check.key.backendIP] = true
}
for ip := range h.marks {
if _, ok :... | go | {
"resource": ""
} |
q26271 | NewNotifier | train | func NewNotifier(ec *EngineConfig) (*Notifier, error) {
outgoing := make(chan Notification, 1)
n := &Notifier{
C: outgoing,
outgoing: outgoing,
reload: make(chan bool, 1),
shutdown: make(chan bool, 1),
engineCfg: ec,
source: SourcePeer,
}
note, err := n.bootstrap()
if err != nil {
re... | go | {
"resource": ""
} |
q26272 | Source | train | func (n *Notifier) Source() Source {
n.lock.RLock()
defer n.lock.RUnlock()
return n.source
} | go | {
"resource": ""
} |
q26273 | SetSource | train | func (n *Notifier) SetSource(source Source) {
n.lock.Lock()
n.source = source
n.lock.Unlock()
if err := n.Reload(); err != nil {
log.Warningf("Reload failed after setting source: %v", err)
}
} | go | {
"resource": ""
} |
q26274 | Reload | train | func (n *Notifier) Reload() error {
select {
case n.reload <- true:
default:
return errors.New("reload request already queued")
}
return nil
} | go | {
"resource": ""
} |
q26275 | configCheck | train | func (n *Notifier) configCheck() {
log.Infof("Checking for config changes...")
s := n.Source()
last := n.last
note, err := n.pullConfig(s)
if err != nil && s == SourcePeer {
log.Errorf("Failed to pull configuration from peer: %v", err)
n.peerFailures++
if n.peerFailures < n.engineCfg.MaxPeerConfigSyncErrors... | go | {
"resource": ""
} |
q26276 | RegisterEngineConn | train | func RegisterEngineConn(connType string, connFunc func(ctx *ipc.Context) EngineConn) {
engineConns[connType] = connFunc
} | go | {
"resource": ""
} |
q26277 | NewSeesawIPC | train | func NewSeesawIPC(ctx *ipc.Context) (*Seesaw, error) {
if newConn, ok := engineConns["ipc"]; ok {
return &Seesaw{newConn(ctx)}, nil
}
return nil, errors.New("No Seesaw IPC connection type registered")
} | go | {
"resource": ""
} |
q26278 | svcOpt | train | func svcOpt(cfg *conf.ConfigFile, service, option string, required bool) string {
// TODO(jsing): Add support for defaults.
opt := cfgOpt(cfg, service, option)
if opt == "" && required {
log.Fatalf("Service %s has missing %s option", service, option)
}
return opt
} | go | {
"resource": ""
} |
q26279 | Failover | train | func (s *SeesawEngine) Failover(ctx *ipc.Context, reply *int) error {
s.trace("Failover", ctx)
if ctx == nil {
return errors.New("context is nil")
}
if !ctx.IsTrusted() {
return errors.New("insufficient access")
}
return s.engine.haManager.requestFailover(false)
} | go | {
"resource": ""
} |
q26280 | HAConfig | train | func (s *SeesawEngine) HAConfig(ctx *ipc.Context, reply *seesaw.HAConfig) error {
s.trace("HAConfig", ctx)
if ctx == nil {
return errors.New("context is nil")
}
if !ctx.IsTrusted() {
return errors.New("insufficient access")
}
c, err := s.engine.haConfig()
if err != nil {
return err
}
if reply != nil {
... | go | {
"resource": ""
} |
q26281 | HAUpdate | train | func (s *SeesawEngine) HAUpdate(args *ipc.HAStatus, failover *bool) error {
if args == nil {
return errors.New("args is nil")
}
ctx := args.Ctx
s.trace("HAUpdate", ctx)
if ctx == nil {
return errors.New("context is nil")
}
if !ctx.IsTrusted() {
return errors.New("insufficient access")
}
s.engine.setHAS... | go | {
"resource": ""
} |
q26282 | HAState | train | func (s *SeesawEngine) HAState(args *ipc.HAState, reply *int) error {
if args == nil {
return errors.New("args is nil")
}
ctx := args.Ctx
s.trace("HAState", ctx)
if ctx == nil {
return errors.New("context is nil")
}
if !ctx.IsTrusted() {
return errors.New("insufficient access")
}
s.engine.setHAState(ar... | go | {
"resource": ""
} |
q26283 | Healthchecks | train | func (s *SeesawEngine) Healthchecks(ctx *ipc.Context, reply *healthcheck.Checks) error {
s.trace("Healthchecks", ctx)
if ctx == nil {
return errors.New("context is nil")
}
if !ctx.IsTrusted() {
return errors.New("insufficient access")
}
configs := s.engine.hcManager.configs()
if reply != nil {
reply.Conf... | go | {
"resource": ""
} |
q26284 | HealthState | train | func (s *SeesawEngine) HealthState(args *healthcheck.HealthState, reply *int) error {
if args == nil {
return errors.New("args is nil")
}
ctx := args.Ctx
s.trace("HealthState", ctx)
if ctx == nil {
return errors.New("context is nil")
}
if !ctx.IsTrusted() {
return errors.New("insufficient access")
}
fo... | go | {
"resource": ""
} |
q26285 | ClusterStatus | train | func (s *SeesawEngine) ClusterStatus(ctx *ipc.Context, reply *seesaw.ClusterStatus) error {
s.trace("ClusterStatus", ctx)
if ctx == nil {
return errors.New("context is nil")
}
if !ctx.IsTrusted() {
return errors.New("insufficient access")
}
s.engine.clusterLock.RLock()
cluster := s.engine.cluster
s.engine... | go | {
"resource": ""
} |
q26286 | VLANs | train | func (s *SeesawEngine) VLANs(ctx *ipc.Context, reply *seesaw.VLANs) error {
s.trace("VLANs", ctx)
if ctx == nil {
return errors.New("context is nil")
}
if !ctx.IsTrusted() {
return errors.New("insufficient access")
}
if reply == nil {
return errors.New("VLANs is nil")
}
reply.VLANs = make([]*seesaw.VLAN... | go | {
"resource": ""
} |
q26287 | OverrideBackend | train | func (s *SeesawEngine) OverrideBackend(args *ipc.Override, reply *int) error {
if args == nil {
return errors.New("args is nil")
}
ctx := args.Ctx
s.trace("OverrideBackend", ctx)
if ctx == nil {
return errors.New("context is nil")
}
if !ctx.IsTrusted() {
return errors.New("insufficient access")
}
if ar... | go | {
"resource": ""
} |
q26288 | ClusterStatus | train | func (c *engineRPC) ClusterStatus() (*seesaw.ClusterStatus, error) {
var cs seesaw.ClusterStatus
if err := c.client.Call("SeesawECU.ClusterStatus", c.ctx, &cs); err != nil {
return nil, err
}
return &cs, nil
} | go | {
"resource": ""
} |
q26289 | Backends | train | func (c *engineRPC) Backends() (map[string]*seesaw.Backend, error) {
var bm seesaw.BackendMap
if err := c.client.Call("SeesawECU.Backends", c.ctx, &bm); err != nil {
return nil, err
}
return bm.Backends, nil
} | go | {
"resource": ""
} |
q26290 | OverrideBackend | train | func (c *engineRPC) OverrideBackend(backend *seesaw.BackendOverride) error {
override := &ipc.Override{Ctx: c.ctx, Backend: backend}
return c.client.Call("SeesawECU.OverrideBackend", override, nil)
} | go | {
"resource": ""
} |
q26291 | NewPingChecker | train | func NewPingChecker(ip net.IP) *PingChecker {
proto := seesaw.IPProtoICMP
if ip.To4() == nil {
proto = seesaw.IPProtoICMPv6
}
id := nextPingCheckerID
nextPingCheckerID++
return &PingChecker{
Target: Target{
IP: ip,
Proto: proto,
},
ID: id,
}
} | go | {
"resource": ""
} |
q26292 | Check | train | func (hc *PingChecker) Check(timeout time.Duration) *Result {
msg := fmt.Sprintf("ICMP ping to host %v", hc.IP)
seq := hc.Seqnum
hc.Seqnum++
echo := newICMPEchoRequest(hc.Proto, hc.ID, seq, 64, []byte("Healthcheck"))
start := time.Now()
if timeout == time.Duration(0) {
timeout = defaultPingTimeout
}
err := ex... | go | {
"resource": ""
} |
q26293 | NewIPHAConn | train | func NewIPHAConn(laddr, raddr net.IP) (HAConn, error) {
sendConn, err := IPConn(laddr, raddr)
if err != nil {
return nil, err
}
// For IPv6 unicast and multicast, and for IPv4 unicast, we can use the same IPConn for both
// sending and receiving. For IPv4 multicast, we need a separate listener for receiving.
r... | go | {
"resource": ""
} |
q26294 | ListenMulticastIPv4 | train | func ListenMulticastIPv4(gaddr, laddr net.IP) (*net.IPConn, error) {
gaddr = gaddr.To4()
laddr = laddr.To4()
c, err := net.ListenIP("ip4:112", &net.IPAddr{IP: gaddr})
if err != nil {
return nil, err
}
f, err := c.File()
if err != nil {
return nil, err
}
defer f.Close()
mreq := &syscall.IPMreq{
Multiad... | go | {
"resource": ""
} |
q26295 | JoinMulticastIPv6 | train | func JoinMulticastIPv6(c *net.IPConn, gaddr, laddr net.IP) error {
f, err := c.File()
if err != nil {
return err
}
defer f.Close()
mreq := &syscall.IPv6Mreq{}
copy(mreq.Multiaddr[:], gaddr.To16())
iface, err := findInterface(laddr)
if err != nil {
return err
}
mreq.Interface = uint32(iface.Index)
err =... | go | {
"resource": ""
} |
q26296 | af | train | func (c *IPHAConn) af() int {
if c.laddr.To4() != nil {
return syscall.AF_INET
}
return syscall.AF_INET6
} | go | {
"resource": ""
} |
q26297 | readPacket | train | func (c *IPHAConn) readPacket() (*packet, error) {
switch c.af() {
case syscall.AF_INET:
return c.readIPv4Packet()
case syscall.AF_INET6:
return c.readIPv6Packet()
}
panic("unreachable")
} | go | {
"resource": ""
} |
q26298 | NewWatchdog | train | func NewWatchdog() *Watchdog {
return &Watchdog{
services: make(map[string]*Service),
shutdown: make(chan bool),
}
} | go | {
"resource": ""
} |
q26299 | AddService | train | func (w *Watchdog) AddService(name, binary string) (*Service, error) {
if _, ok := w.services[name]; ok {
return nil, fmt.Errorf("Service %q already exists", name)
}
svc := newService(name, binary)
w.services[name] = svc
return svc, nil
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.