id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c26200 | := item.(Organization); ok {
fullOrgsList = append(fullOrgsList, app)
} else {
return ccerror.UnknownObjectInListError{
Expected: Organization{},
Unexpected: item,
}
}
return nil
})
return fullOrgsList, warnings, err
} | |
c26201 |
var fullOrgsList []Organization
warnings, err := client.paginate(request, Organization{}, func(item interface{}) error {
if app, ok := item.(Organization); ok {
fullOrgsList = append(fullOrgsList, app)
} else {
return ccerror.UnknownObjectInListError{
Expected: Organization{},
Unexpected: item,
... | |
c26202 |
}
var responseDroplet Droplet
response := cloudcontroller.Response{
DecodeJSONResponseInto: &responseDroplet,
}
err = client.connection.Make(request, &response)
return responseDroplet, response.Warnings, err
} | |
c26203 |
var responseDroplet Droplet
response := cloudcontroller.Response{
DecodeJSONResponseInto: &responseDroplet,
}
err = client.connection.Make(request, &response)
return responseDroplet, response.Warnings, err
} | |
c26204 | item.(Droplet); ok {
responseDroplets = append(responseDroplets, droplet)
} else {
return ccerror.UnknownObjectInListError{
Expected: Droplet{},
Unexpected: item,
}
}
return nil
})
return responseDroplets, warnings, err
} | |
c26205 | err := strconv.Atoi(val)
return err
} | |
c26206 | ok {
fullServiceInstanceList = append(fullServiceInstanceList, serviceInstance)
} else {
return ccerror.UnknownObjectInListError{
Expected: ServiceInstance{},
Unexpected: item,
}
}
return nil
})
return fullServiceInstanceList, warnings, err
} | |
c26207 | nil {
return err
}
routeMapping.GUID = ccRouteMapping.Metadata.GUID
routeMapping.AppGUID = ccRouteMapping.Entity.AppGUID
routeMapping.RouteGUID = ccRouteMapping.Entity.RouteGUID
return nil
} | |
c26208 |
var routeMapping RouteMapping
response := cloudcontroller.Response{
DecodeJSONResponseInto: &routeMapping,
}
err = client.connection.Make(request, &response)
return routeMapping, response.Warnings, err
} | |
c26209 | routeMapping, ok := item.(RouteMapping); ok {
fullRouteMappingsList = append(fullRouteMappingsList, routeMapping)
} else {
return ccerror.UnknownObjectInListError{
Expected: RouteMapping{},
Unexpected: item,
}
}
return nil
})
return fullRouteMappingsList, warnings, err
} | |
c26210 | %s", refreshTokenResponse.Type, refreshTokenResponse.AccessToken)
} | |
c26211 |
})
if err != nil {
return RefreshedTokens{}, err
}
if client.config.UAAGrantType() != string(constant.GrantTypeClientCredentials) {
request.SetBasicAuth(client.config.UAAOAuthClient(), client.config.UAAOAuthClientSecret())
}
var refreshResponse RefreshedTokens
response := Response{
Result: &refreshRespo... | |
c26212 | if len(row) > 0 {
displayTable = append(displayTable, row)
}
}
columns := len(displayTable[0])
if columns < 2 || !ui.IsTTY {
ui.DisplayNonWrappingTable(prefix, displayTable, padding)
return
}
ui.displayWrappingTableWithWidth(prefix, displayTable, padding)
} | |
c26213 | for row := 0; row < rows; row++ {
fmt.Fprint(ui.Out, prefix)
for col := 0; col < columns; col++ {
data := table[row][col]
var addedPadding int
if col+1 != columns {
addedPadding = columnPadding[col] - wordSize(data)
}
fmt.Fprintf(ui.Out, "%s%s", data, strings.Repeat(" ", addedPadding))
}
fmt... | |
c26214 | color.New(color.Bold))
}
ui.DisplayNonWrappingTable(prefix, table, padding)
} | |
c26215 | for instanceID, instance := range instances {
id, convertErr := strconv.Atoi(instanceID)
if convertErr != nil {
return nil, response.Warnings, convertErr
}
instance.ID = id
returnedInstances[id] = instance
}
return returnedInstances, response.Warnings, nil
} | |
c26216 | return err
}
servicePlanVisibility.GUID = ccServicePlanVisibility.Metadata.GUID
servicePlanVisibility.ServicePlanGUID = ccServicePlanVisibility.Entity.ServicePlanGUID
servicePlanVisibility.OrganizationGUID = ccServicePlanVisibility.Entity.OrganizationGUID
return nil
} | |
c26217 | err
}
var fullVisibilityList []ServicePlanVisibility
warnings, err := client.paginate(request, ServicePlanVisibility{}, func(item interface{}) error {
if vis, ok := item.(ServicePlanVisibility); ok {
fullVisibilityList = append(fullVisibilityList, vis)
} else {
return ccerror.UnknownObjectInListError{
... | |
c26218 | := logger.displayResponse(passedResponse)
if displayErr != nil {
logger.output.HandleInternalError(displayErr)
}
}
return err
} | |
c26219 | nil {
return err
}
spaceQuota.GUID = ccSpaceQuota.Metadata.GUID
spaceQuota.Name = ccSpaceQuota.Entity.Name
return nil
} | |
c26220 |
}
var spaceQuota SpaceQuota
response := cloudcontroller.Response{
DecodeJSONResponseInto: &spaceQuota,
}
err = client.connection.Make(request, &response)
return spaceQuota, response.Warnings, err
} | |
c26221 | return nil, nil, err
}
var spaceQuotas []SpaceQuota
warnings, err := client.paginate(request, SpaceQuota{}, func(item interface{}) error {
if spaceQuota, ok := item.(SpaceQuota); ok {
spaceQuotas = append(spaceQuotas, spaceQuota)
} else {
return ccerror.UnknownObjectInListError{
Expected: SpaceQuot... | |
c26222 |
return nil, err
}
response := cloudcontroller.Response{}
err = client.connection.Make(request, &response)
return response.Warnings, err
} | |
c26223 |
return Organization{}, Warnings(warnings), actionerror.OrganizationNotFoundError{GUID: guid}
}
return Organization(org), Warnings(warnings), err
} | |
c26224 | _, org := range orgs {
guids = append(guids, org.GUID)
}
return Organization{}, Warnings(warnings), actionerror.MultipleOrganizationsFoundError{Name: orgName, GUIDs: guids}
}
return Organization(orgs[0]), Warnings(warnings), nil
} | |
c26225 | {
warnings, err = actor.CloudControllerClient.UpdateOrganizationManagerByUsername(guid, username)
} else {
warnings, err = actor.CloudControllerClient.UpdateOrganizationManager(guid, username)
}
return Warnings(warnings), err
} | |
c26226 | allWarnings, err
}
quotaGUID = quota.GUID
}
org, warnings, err := actor.CloudControllerClient.CreateOrganization(orgName, quotaGUID)
allWarnings = append(allWarnings, warnings...)
if _, ok := err.(ccerror.OrganizationNameTakenError); ok {
return Organization{}, allWarnings, actionerror.OrganizationNameTake... | |
c26227 | nil {
return allWarnings, err
}
ccWarnings, err := actor.CloudControllerClient.PollJob(job)
for _, warning := range ccWarnings {
allWarnings = append(allWarnings, warning)
}
return allWarnings, err
} | |
c26228 | {
returnedOrgs = append(returnedOrgs, Organization(org))
}
return returnedOrgs, Warnings(warnings), err
} | |
c26229 | if err != nil {
return false, Warnings(warnings), err
}
if len(orgs) == 0 {
return false, Warnings(warnings), nil
}
return true, Warnings(warnings), nil
} | |
c26230 | in, out)
}()
select {
case err := <-ch:
return err
case <-time.After(nccRPCTimeout):
return fmt.Errorf("RPC call timed out after %v", nccRPCTimeout)
}
} | |
c26231 | ok := stateNames[s]; ok {
return name
}
return "<unknown>"
} | |
c26232 | %d)", t.Host, t.Mark)
}
return fmt.Sprintf("%s %s%s", t.addr(), t.Mode, via)
} | |
c26233 | }
return fmt.Sprintf("[%v]:%d", t.IP, t.Port)
} | |
c26234 | case seesaw.IPProtoICMPv6:
network = "ip6:ipv6-icmp"
case seesaw.IPProtoTCP:
network = fmt.Sprintf("tcp%d", version)
case seesaw.IPProtoUDP:
network = fmt.Sprintf("udp%d", version)
default:
return "(unknown)"
}
return network
} | |
c26235 | return r.Err.Error()
}
return r.Message
} | |
c26236 | time.Since(start)
return &Result{msg, success, duration, err}
} | |
c26237 | {
return fmt.Sprintf("ID 0x%x %v", n.Id, n.State)
} | |
c26238 | id,
Interval: 5 * time.Second,
Timeout: 30 * time.Second,
Retries: 0,
Checker: checker,
}
} | |
c26239 | make(chan Config, 1),
quit: make(chan bool, 1),
}
} | |
c26240 | hc.result != nil {
status.Duration = hc.result.Duration
status.Message = hc.result.String()
}
return status
} | |
c26241 | hc.Id, hc)
return
case config := <-hc.update:
if hc.Interval != config.Interval {
ticker.Stop()
if start != nil {
<-start
}
ticker = time.NewTicker(config.Interval)
}
hc.Config = config
case <-ticker.C:
hc.healthcheck()
}
}
} | |
c26242 |
if hc.state == StateHealthy && hc.failed > 0 && hc.failed <= uint64(hc.Config.Retries) {
log.Infof("%d: Failure %d - retrying...", hc.Id, hc.failed)
state = StateHealthy
}
transition := (hc.state != state)
hc.state = state
hc.lock.Unlock()
if transition {
hc.Notify()
}
} | |
c26243 | &Notification{
Id: hc.Id,
Status: hc.Status(),
}
} | |
c26244 | {
case result := <-ch:
return result
case <-time.After(hc.Timeout):
return &Result{"Timed out", false, hc.Timeout, nil}
}
} | |
c26245 |
hc.blocking = block
hc.update = make(chan Config, len)
} | |
c26246 | *config:
default:
log.Warningf("Unable to update %d (%s), last update still queued", hc.Id, hc)
}
} | |
c26247 | configs: make(chan map[Id]*Config),
batch: make([]*Notification, 0, cfg.BatchSize),
quit: make(chan bool, 1),
}
} | |
c26248 | go s.manager()
<-s.quit
} | |
c26249 | err := engine.Call("SeesawEngine.Healthchecks", ctx, &checks); err != nil {
return nil, fmt.Errorf("SeesawEngine.Healthchecks failed: %v", err)
}
return &checks, nil
} | |
c26250 | log.Infof("Engine returned %d healthchecks", len(checks.Configs))
s.configs <- checks.Configs
time.Sleep(15 * time.Second)
}
}
} | |
c26251 |
// Update configurations.
for id, hc := range s.healthchecks {
hc.Update(configs[id])
}
case <-notifyTicker.C:
// Send status notifications for all healthchecks.
for _, hc := range s.healthchecks {
hc.Notify()
}
}
}
} | |
c26252 | timer = time.After(s.config.BatchDelay)
case s.config.BatchSize:
err = s.send()
timer = nil
}
case <-timer:
err = s.send()
}
if err != nil {
log.Fatal(err)
}
}
} | |
c26253 | %d errors, giving up", failures)
}
time.Sleep(s.config.RetryDelay)
}
s.batch = s.batch[:0]
return nil
} | |
c26254 | var reply int
ctx := ipc.NewTrustedContext(seesaw.SCHealthcheck)
return engine.Call("SeesawEngine.HealthState", &HealthState{ctx, batch}, &reply)
} | |
c26255 | time.Unix(0, 0),
lastSuccess: time.Unix(0, 0),
},
}
} | |
c26256 | append(e.publishers, p)
} | |
c26257 | from Seesaw Engine...")
if err := e.update(); err != nil {
log.Warning(err)
} else {
e.stats.lock.Lock()
e.stats.lastSuccess = time.Now()
e.stats.lock.Unlock()
}
for _, p := range e.publishers {
p.update(e.stats)
}
<-ticker.C
}
} | |
c26258 | fmt.Errorf("Failed to get BGP neighbors: %v", err)
}
e.stats.lock.Lock()
e.stats.neighbors = neighbors
e.stats.lock.Unlock()
vlans, err := seesawConn.VLANs()
if err != nil {
return fmt.Errorf("Failed to get VLANs: %v", err)
}
e.stats.lock.Lock()
e.stats.vlans = vlans.VLANs
e.stats.lock.Unlock()
vservers... | |
c26259 | ncc: ncclient.NewNCC(e.config.NCCSocket),
next: healthcheck.Id((uint64(os.Getpid()) & 0xFFFF) << 48),
vserverChecks: make(map[string]map[checkKey]*check),
quit: make(chan bool),
stopped: make(chan bool),
vcc: make(chan vserverChecks, 100),
}
} | |
c26260 | defer h.lock.RUnlock()
if !h.enabled {
return nil
}
return h.cfgs
} | |
c26261 | vserverName)
} else {
h.vserverChecks[vserverName] = checks
}
h.buildMaps()
} | |
c26262 | h.lock.Unlock()
h.enabled = true
} | |
c26263 | h.lock.Unlock()
h.enabled = false
} | |
c26264 |
for key, c := range allChecks {
id, ok := ids[key]
if !ok {
id = h.next
h.next++
}
// Create a new healthcheck configuration if one did not
// previously exist, or if the check configuration changed.
cfg, ok := cfgs[id]
if !ok || *checks[id].healthcheck != *c.healthcheck {
newCfg, err := h.ne... | |
c26265 | h.lock.RUnlock()
if !enabled {
log.Warningf("Healthcheck manager is disabled; ignoring healthcheck notification %v", n)
return nil
}
h.engine.syncServer.notify(&SyncNote{Type: SNTHealthcheck, Healthcheck: n})
return h.queueHealthState(n)
} | |
c26266 | == nil {
log.Warningf("Unknown healthcheck ID %v", n.Id)
return nil
}
note := &checkNotification{
key: check.key,
description: cfg.Checker.String(),
status: n.Status,
}
check.vserver.queueCheckNotification(note)
return nil
} | |
c26267 | case vc := <-h.vcc:
h.update(vc.vserverName, vc.checks)
}
}
} | |
c26268 | := healthcheck.Status{State: healthcheck.StateUnknown}
for _, id := range ids {
h.queueHealthState(&healthcheck.Notification{id, status})
}
} | |
c26269 | },
}
if err := h.ncc.Dial(); err != nil {
log.Fatalf("Failed to connect to NCC: %v", err)
}
defer h.ncc.Close()
log.Infof("Adding DSR IPVS service for %s (mark %d)", backend, mark)
if err := h.ncc.IPVSAddService(ipvsSvc); err != nil {
log.Fatalf("Failed to add IPVS service for DSR: %v", err)
}
return ma... | |
c26270 |
backends[check.key.backendIP] = true
}
for ip := range h.marks {
if _, ok := backends[ip]; !ok {
h.unmarkBackend(ip)
}
}
} | |
c26271 | dNote == nil || !dNote.Cluster.Equal(note.Cluster) {
if err := saveConfig(note.protobuf, n.engineCfg.ClusterFile, true); err != nil {
log.Warningf("Failed to save config to %s: %v", n.engineCfg.ClusterFile, err)
}
}
}
n.last = note
n.outgoing <- *note
go n.run()
return n, nil
} | |
c26272 | n.lock.RUnlock()
return n.source
} | |
c26273 | nil {
log.Warningf("Reload failed after setting source: %v", err)
}
} | |
c26274 | <- true:
default:
return errors.New("reload request already queued")
}
return nil
} | |
c26275 |
oldCluster := *n.last.Cluster
oldCluster.Status = seesaw.ConfigStatus{}
newCluster := *note.Cluster
newCluster.Status = seesaw.ConfigStatus{}
if newCluster.Equal(&oldCluster) {
note.MetadataOnly = true
}
log.Infof("Sending config update notification")
n.last = note
n.outgoing <- *note
log.Infof("Sent conf... | |
c26276 | func(ctx *ipc.Context) EngineConn) {
engineConns[connType] = connFunc
} | |
c26277 |
return nil, errors.New("No Seesaw IPC connection type registered")
} | |
c26278 | defaults.
opt := cfgOpt(cfg, service, option)
if opt == "" && required {
log.Fatalf("Service %s has missing %s option", service, option)
}
return opt
} | |
c26279 |
return errors.New("context is nil")
}
if !ctx.IsTrusted() {
return errors.New("insufficient access")
}
return s.engine.haManager.requestFailover(false)
} | |
c26280 | c, err := s.engine.haConfig()
if err != nil {
return err
}
if reply != nil {
reply.Copy(c)
}
return nil
} | |
c26281 | !ctx.IsTrusted() {
return errors.New("insufficient access")
}
s.engine.setHAStatus(args.Status)
if failover != nil {
*failover = s.engine.haManager.failover()
}
return nil
} | |
c26282 |
if !ctx.IsTrusted() {
return errors.New("insufficient access")
}
s.engine.setHAState(args.State)
return nil
} | |
c26283 | is nil")
}
if !ctx.IsTrusted() {
return errors.New("insufficient access")
}
configs := s.engine.hcManager.configs()
if reply != nil {
reply.Configs = configs
}
return nil
} | |
c26284 | !ctx.IsTrusted() {
return errors.New("insufficient access")
}
for _, n := range args.Notifications {
if err := s.engine.hcManager.healthState(n); err != nil {
return err
}
}
return nil
} | |
c26285 | configuration loaded")
}
reply.Version = seesaw.SeesawVersion
reply.Site = cluster.Site
reply.Nodes = make([]*seesaw.Node, 0, len(cluster.Nodes))
for _, node := range cluster.Nodes {
reply.Nodes = append(reply.Nodes, node.Clone())
}
return nil
} | |
c26286 |
reply.VLANs = make([]*seesaw.VLAN, 0)
s.engine.vlanLock.RLock()
for _, vlan := range s.engine.vlans {
reply.VLANs = append(reply.VLANs, vlan)
}
s.engine.vlanLock.RUnlock()
return nil
} | |
c26287 | !ctx.IsTrusted() {
return errors.New("insufficient access")
}
if args.Backend == nil {
return errors.New("backend is nil")
}
s.engine.queueOverride(args.Backend)
return nil
} | |
c26288 | c.client.Call("SeesawECU.ClusterStatus", c.ctx, &cs); err != nil {
return nil, err
}
return &cs, nil
} | |
c26289 | c.client.Call("SeesawECU.Backends", c.ctx, &bm); err != nil {
return nil, err
}
return bm.Backends, nil
} | |
c26290 | backend}
return c.client.Call("SeesawECU.OverrideBackend", override, nil)
} | |
c26291 |
return &PingChecker{
Target: Target{
IP: ip,
Proto: proto,
},
ID: id,
}
} | |
c26292 | defaultPingTimeout
}
err := exchangeICMPEcho(hc.network(), hc.IP, timeout, echo)
success := err == nil
return complete(start, msg, success, err)
} | |
c26293 | return nil, err
}
} else {
log.Infof("Using IPv6 multicast")
if err = JoinMulticastIPv6(recvConn, raddr, laddr); err != nil {
return nil, err
}
}
}
return &IPHAConn{
sendConn: sendConn,
recvConn: recvConn,
laddr: laddr,
raddr: raddr,
}, nil
} | |
c26294 |
Multiaddr: [4]byte{gaddr[0], gaddr[1], gaddr[2], gaddr[3]},
Interface: [4]byte{laddr[0], laddr[1], laddr[2], laddr[3]},
}
err = syscall.SetsockoptIPMreq(int(f.Fd()), syscall.IPPROTO_IP, syscall.IP_ADD_MEMBERSHIP, mreq)
if err != nil {
return nil, err
}
return c, nil
} | |
c26295 |
mreq.Interface = uint32(iface.Index)
err = syscall.SetsockoptIPv6Mreq(int(f.Fd()), syscall.IPPROTO_IPV6, syscall.IPV6_JOIN_GROUP, mreq)
if err != nil {
return err
}
return nil
} | |
c26296 | return syscall.AF_INET
}
return syscall.AF_INET6
} | |
c26297 |
case syscall.AF_INET6:
return c.readIPv6Packet()
}
panic("unreachable")
} | |
c26298 |
services: make(map[string]*Service),
shutdown: make(chan bool),
}
} | |
c26299 | {
return nil, fmt.Errorf("Service %q already exists", name)
}
svc := newService(name, binary)
w.services[name] = svc
return svc, nil
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.