id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c171400 | int32) {
atomic.StoreInt32(&b.gap, gap)
} | |
c171401 | int32) {
atomic.StoreInt32(&b.barWidth, size)
} | |
c171402 | defer b.mtx.Unlock()
b.showTitles = show
} | |
c171403 | int32) {
atomic.StoreInt32(&b.legendWidth, width)
} | |
c171404 | defer b.mtx.Unlock()
b.onDrawCell = fn
} | |
c171405 | defer b.mtx.Unlock()
b.showMarks = show
} | |
c171406 |
if fn == nil {
w.onKeyDown = nil
} else {
w.onKeyDown = &keyDownCb{data: data, fn: fn}
}
} | |
c171407 | height)
} else {
w.maximized = false
w.SetPos(w.origX, w.origY)
w.SetSize(w.origWidth, w.origHeight)
}
w.ResizeChildren()
w.PlaceChildren()
} | |
c171408 | WindowManager().moveActiveWindowToBottom()
}
} else {
WindowManager().activateWindow(w)
}
}
} | |
c171409 | defer b.mtx.Unlock()
b.topValue = top
} | |
c171410 | defer b.mtx.Unlock()
b.autosize = auto
} | |
c171411 | defer b.mtx.Unlock()
b.hiliteMax = hilite
} | |
c171412 | }
}
// set the GOPATH if using >= 1.8 and the GOPATH isn't set
if os.Getenv("GOPATH") == "" {
out, err := exec.Command("go", "env", "GOPATH").Output()
if err == nil {
gp := strings.TrimSpace(string(out))
os.Setenv("GOPATH", gp)
}
}
for _, e := range os.Environ() {
pair := strings.Split(e, "=")
env[pair[0]] = os.Getenv(pair[0])
}
} | |
c171413 |
defer gil.RUnlock()
if v, ok := env[key]; ok {
return v
}
return value
} | |
c171414 | if v, ok := env[key]; ok {
return v, nil
}
return "", fmt.Errorf("could not find ENV var with %s", key)
} | |
c171415 | gil.Unlock()
env[key] = value
} | |
c171416 | nil {
return err
}
env[key] = value
return nil
} | |
c171417 | a different separator
}
return strings.Split(gp, ":")
} | |
c171418 | := modfile.ModulePath(moddata)
if packagePath == "" {
return "", errors.New("go.mod is malformed")
}
return packagePath, nil
} | |
c171419 |
req.Header.Set("Content-Type", "application/json")
resp, err := client.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
return processResponse(resp)
} | |
c171420 | nil && pn.FCM == nil {
return errors.New("PushNotification must contain a GCM, FCM or APNS payload")
}
return nil
} | |
c171421 | parts = 4
}
if coercedIP == nil {
return nil
}
nn := make(NetworkNumber, parts)
for i := 0; i < parts; i++ {
idx := i * net.IPv4len
nn[i] = binary.BigEndian.Uint32(coercedIP[idx : idx+net.IPv4len])
}
return nn
} | |
c171422 | }
if len(ip) == net.IPv4len {
ip = net.IPv4(ip[0], ip[1], ip[2], ip[3])
}
return ip
} | |
c171423 | return n[1] == n1[1] && n[2] == n1[2] && n[3] == n1[3]
}
return true
} | |
c171424 | copy(newIP, n)
for i := len(newIP) - 1; i >= 0; i-- {
newIP[i]++
if newIP[i] > 0 {
break
}
}
return newIP
} | |
c171425 | n)
for i := len(newIP) - 1; i >= 0; i-- {
newIP[i]--
if newIP[i] < math.MaxUint32 {
break
}
}
return newIP
} | |
c171426 | NetworkNumberMask(NewNetworkNumber(net.IP(ipNet.Mask))),
}
} | |
c171427 | len(n.Number)*BitsPerUint32)
return NewNetwork(net.IPNet{
IP: n.IP.Mask(mask),
Mask: mask,
})
} | |
c171428 | n.Number[1] && nn[2]&n.Mask[2] == n.Number[2] && nn[3]&n.Mask[3] == n.Number[3]
}
return true
} | |
c171429 | _ := o.IPNet.Mask.Size()
return n.Contains(o.Number) && nMaskSize <= oMaskSize
} | |
c171430 | n.Number.LeastCommonBitPosition(n1.Number)
if err != nil {
return 0, err
}
return uint(math.Max(float64(maskPosition), float64(lcb))), nil
} | |
c171431 | n.String() == n1.String()
} | |
c171432 | result[1] = m[1] & n[1]
result[2] = m[2] & n[2]
result[3] = m[3] & n[3]
}
return result, nil
} | |
c171433 | NewNetworkNumber(ip).Next().ToIP()
} | |
c171434 | {
return NewNetworkNumber(ip).Previous().ToIP()
} | |
c171435 | 2, 2),
numBitsSkipped: 0,
numBitsHandled: 1,
network: rnet.NewNetwork(*rootNet),
}
} | |
c171436 |
return p.insert(rnet.NewNetwork(network), entry)
} | |
c171437 | return p.remove(rnet.NewNetwork(network))
} | |
c171438 | false, ErrInvalidNetworkNumberInput
}
return p.contains(nn)
} | |
c171439 |
}
return fmt.Sprintf("%s (target_pos:%d:has_entry:%t)%s", p.network,
p.targetBitPosition(), p.hasEntry(), strings.Join(children, ""))
} | |
c171440 | _, childEntries := range childEntriesList {
for entry := range childEntries {
entries <- entry
}
}
close(entries)
}()
return entries
} | |
c171441 | make(map[string]RangerEntry),
ipV6Entries: make(map[string]RangerEntry),
}
} | |
c171442 | := b.getEntriesByVersion(entry.Network().IP)
if err != nil {
return err
}
entries[key] = entry
}
return nil
} | |
c171443 | found := networks[key]; found {
delete(networks, key)
return networkToDelete, nil
}
return nil, nil
} | |
c171444 | network := entry.Network()
if network.Contains(ip) {
return true, nil
}
}
return false, nil
} | |
c171445 |
if mt, ok := messageTypeMap[ircMessage.Command]; ok {
return mt.Parser(ircMessage)
}
return parseRawMessage(ircMessage)
} | |
c171446 |
write: make(chan string, WriteBufferSize),
// NOTE: IdlePingInterval must be higher than PongTimeout
SendPings: true,
IdlePingInterval: time.Second * 15,
PongTimeout: time.Second * 5,
channelUserlistMutex: &sync.RWMutex{},
}
} | |
c171447 | strings.ToLower(channel)
c.send(fmt.Sprintf("PRIVMSG #%s :%s", channel, text))
} | |
c171448 | %s %s", c.ircUser, username, text))
} | |
c171449 |
c.channels[channel] = true
c.channelUserlistMutex.Lock()
c.channelUserlist[channel] = map[string]bool{}
c.channelUserlistMutex.Unlock()
c.channelsMtx.Unlock()
} | |
c171450 | c.channelsMtx.Lock()
delete(c.channels, channel)
c.channelUserlistMutex.Lock()
delete(c.channelUserlist, channel)
c.channelUserlistMutex.Unlock()
c.channelsMtx.Unlock()
} | |
c171451 | {
return ErrConnectionIsNotOpen
}
c.userDisconnect.Close()
return nil
} | |
c171452 |
conf = &tls.Config{
InsecureSkipVerify: true,
}
} else {
conf = &tls.Config{}
}
for {
err := c.makeConnection(dialer, conf)
switch err {
case errReconnect:
continue
default:
return err
}
}
} | |
c171453 | '%s' in client", channel)
}
userlist := make([]string, len(usermap))
i := 0
for key := range usermap {
userlist[i] = key
i++
}
return userlist, nil
} | |
c171454 |
}
}
return nil
case *UserPartMessage:
if c.handleUserPartMessage(*msg) {
if c.onUserPartMessage != nil {
c.onUserPartMessage(*msg)
}
}
return nil
case *ReconnectMessage:
// https://dev.twitch.tv/docs/irc/commands/#reconnect-twitch-commands
if c.onReconnectMessage != nil {
c.onReconnectMessage(*msg)
}
return errReconnect
case *NamesMessage:
if c.onNamesMessage != nil {
c.onNamesMessage(*msg)
}
c.handleNamesMessage(*msg)
return nil
case *PingMessage:
if c.onPingMessage != nil {
c.onPingMessage(*msg)
}
c.handlePingMessage(*msg)
return nil
case *PongMessage:
if c.onPongMessage != nil {
c.onPongMessage(*msg)
}
c.handlePongMessage(*msg)
return nil
case *RawMessage:
if c.onUnsetMessage != nil {
c.onUnsetMessage(*msg)
}
}
return nil
} | |
c171455 | err
}
if err := os.MkdirAll("ci/tasks", 0755); err == nil {
targetFile = filepath.Join("ci", "tasks", cfMgmtYml)
lo.G.Debug("Creating", targetFile)
if err = createFile(cfMgmtYml, targetFile); err != nil {
lo.G.Error("Error creating cf-mgmt.yml", err)
return err
}
targetFile = filepath.Join("ci", "tasks", cfMgmtSh)
lo.G.Debug("Creating", targetFile)
if err = createFile(cfMgmtSh, targetFile); err != nil {
lo.G.Error("Error creating cf-mgmt.sh", err)
return err
}
} else {
lo.G.Error("Error making directories", err)
return err
}
fmt.Println("1) Update vars.yml with the appropriate values")
fmt.Println("2) Using following command to set your pipeline in concourse after you have checked all files in to git")
fmt.Println("fly -t lite set-pipeline -p cf-mgmt -c pipeline.yml --load-vars-from=vars.yml")
return nil
} | |
c171456 | {
return cfMgmt.UserManager.CleanupOrgUsers()
}
return nil
} | |
c171457 |
missing = append(missing, *seg)
}
}
var extra []cfclient.IsolationSegment
for name, seg := range currentSegments {
if _, ok := desiredSegments[name]; !ok {
extra = append(extra, *seg)
}
}
return classification{missing, extra}
} | |
c171458 | err = cfMgmt.SecurityGroupManager.CreateApplicationSecurityGroups()
}
return err
} | |
c171459 | c.Peek); err == nil {
err = cfMgmt.SpaceManager.UpdateSpacesMetadata()
}
return err
} | |
c171460 | "unlimited",
PaidServicePlansAllowed: true,
}
}
errorString := ""
updateSpaceNamedQuotaConfig(spaceQuota, c.Quota, &errorString)
if errorString != "" {
return errors.New(errorString)
}
return c.ConfigManager.SaveSpaceQuota(spaceQuota)
} | |
c171461 | []byte("[]")
if c.FilePath != "" {
bytes, err := config.LoadFileBytes(c.FilePath)
if err != nil {
return err
}
securityGroupsBytes = bytes
}
if c.ASGType == "space" {
if err := config.NewManager(c.ConfigDirectory).AddSecurityGroup(c.ASGName, securityGroupsBytes); err != nil {
return err
}
} else {
if err := config.NewManager(c.ConfigDirectory).AddDefaultSecurityGroup(c.ASGName, securityGroupsBytes); err != nil {
return err
}
}
fmt.Println(fmt.Sprintf("The asg [%s] has been updated", c.ASGName))
return nil
} | |
c171462 | := cfMgmt.UserManager.InitializeLdap(c.LdapUser, c.LdapPassword, c.LdapServer); err != nil {
return err
}
defer cfMgmt.UserManager.DeinitializeLdap()
return cfMgmt.UserManager.UpdateSpaceUsers()
}
return nil
} | |
c171463 | c.Peek); err == nil {
err = cfMgmt.OrgManager.DeleteOrgs()
}
return err
} | |
c171464 | "unlimited",
PaidServicePlansAllowed: true,
}
}
errorString := ""
updateOrgNamedQuotaConfig(orgQuota, c.Quota, &errorString)
if errorString != "" {
return errors.New(errorString)
}
return c.ConfigManager.SaveOrgQuota(orgQuota)
} | |
c171465 | if strings.ToUpper(v) == spaceNameToUpper {
return true
}
}
return false
} | |
c171466 | c.Peek); err == nil {
err = cfMgmt.QuotaManager.CreateOrgQuotas()
}
return err
} | |
c171467 | c.Peek); err == nil {
err = cfMgmt.QuotaManager.CreateSpaceQuotas()
}
return err
} | |
c171468 | err := LoadFile(configFile, &input); err != nil {
return nil, err
}
return input, nil
} | |
c171469 | len(globalConfig.MetadataPrefix) == 0 {
globalConfig.MetadataPrefix = "cf-mgmt.pivotal.io"
}
return globalConfig, nil
} | |
c171470 | result[i].TotalServiceKeys = unlimited
result[i].InstanceMemoryLimit = unlimited
if err = LoadFile(f, &result[i]); err != nil {
lo.G.Error(err)
return nil, err
}
}
return result, nil
} | |
c171471 | nil
}
result := SpaceConfig{}
err := LoadFile(fp, &result)
return &result, err
} | |
c171472 | -> %v", orgName, orgList.Orgs)
}
lo.G.Infof("Adding org: %s ", orgName)
orgList.Orgs = append(orgList.Orgs, orgName)
if err = m.SaveOrgs(orgList); err != nil {
return err
}
m.SaveOrgConfig(orgConfig)
return m.SaveOrgSpaces(spaces)
} | |
c171473 | fmt.Errorf("space [%s] already added to config -> [%v]", spaceName, spaceList.Spaces)
}
lo.G.Infof("Adding space: %s ", spaceName)
spaceList.Spaces = append(spaceList.Spaces, spaceName)
if err := WriteFile(spaceFileName, spaceList); err != nil {
return err
}
if err := m.SaveSpaceConfig(spaceConfig); err != nil {
return err
}
if err := WriteFileBytes(fmt.Sprintf("%s/%s/%s/security-group.json", m.ConfigDir, orgName, spaceName), []byte("[]")); err != nil {
return err
}
return nil
} | |
c171474 | directory %s: %v", orgQuotasDir, err)
}
lo.G.Infof("OrgQuotas directory %s created", orgQuotasDir)
if err := m.SaveGlobalConfig(&GlobalConfig{}); err != nil {
return err
}
if err := WriteFile(fmt.Sprintf("%s/ldap.yml", m.ConfigDir), &LdapConfig{TLS: false, Origin: uaaOrigin}); err != nil {
return err
}
if err := WriteFile(fmt.Sprintf("%s/orgs.yml", m.ConfigDir), &Orgs{
EnableDeleteOrgs: true,
ProtectedOrgs: DefaultProtectedOrgs,
}); err != nil {
return err
}
if err := WriteFile(fmt.Sprintf("%s/spaceDefaults.yml", m.ConfigDir), struct {
Developer UserMgmt `yaml:"space-developer"`
Manager UserMgmt `yaml:"space-manager"`
Auditor UserMgmt `yaml:"space-auditor"`
}{}); err != nil {
return err
}
return nil
} | |
c171475 | folder. Error: %s", err)
return fmt.Errorf("cannot delete %s: %v", m.ConfigDir, err)
}
lo.G.Info("Config directory deleted")
return nil
} | |
c171476 | return err
}
spaces.Replace(c.SpaceName, c.NewSpaceName)
err = c.ConfigManager.SaveOrgSpaces(spaces)
if err != nil {
return err
}
fmt.Println(fmt.Sprintf("The org/space [%s/%s] has been renamed to [%s/%s]", c.OrgName, c.SpaceName, c.OrgName, c.NewSpaceName))
return nil
} | |
c171477 | c.Peek); err == nil {
err = cfMgmt.SpaceManager.CreateSpaces()
}
return err
} | |
c171478 | with %s from org %s", space.Name, orgName)
return nil
}
lo.G.Infof("delete space with %s from org %s", space.Name, orgName)
return m.Client.DeleteSpace(space.Guid, true, false)
} | |
c171479 | orgManager,
SecurityGroupManager: securityGroupManager,
IsoSegmentManager: isoSegmentMgr,
PrivateDomainManager: privateDomainMgr,
SharedDomainManager: sharedDomainMgr,
ServiceAccessManager: serviceAccessMgr,
QuotaManager: quotaMgr,
}
} | |
c171480 | if strings.ToUpper(org) == orgNameUpper {
return true
}
}
return false
} | |
c171481 | if isolationSegmentGUID != "" {
lo.G.Infof("set default isolation segment for org %s to %s", oc.Org, oc.DefaultIsoSegment)
err = u.Client.DefaultIsolationSegmentForOrg(org.Guid, isolationSegmentGUID)
if err != nil {
return err
}
} else {
lo.G.Infof("reset default isolation segment for org %s", oc.Org)
err = u.Client.ResetDefaultIsolationSegmentForOrg(org.Guid)
if err != nil {
return err
}
}
}
}
return nil
} | |
c171482 | if sc.IsoSegment != "" {
lo.G.Infof("set isolation segment for space %s to %s (org %s)", sc.Space, sc.IsoSegment, sc.Org)
err = u.Client.IsolationSegmentForSpace(space.Guid, isolationSegmentGUID)
if err != nil {
return err
}
} else {
lo.G.Infof("reset isolation segment for space %s (org %s)", sc.Space, sc.Org)
err = u.Client.ResetIsolationSegmentForSpace(space.Guid)
if err != nil {
return err
}
}
}
}
return nil
} | |
c171483 | space.IsoSegment != "" {
segments[space.IsoSegment] = struct{}{}
}
}
result := make([]cfclient.IsolationSegment, 0, len(segments))
for k := range segments {
result = append(result, cfclient.IsolationSegment{Name: k})
}
return result, nil
} | |
c171484 | userID [%s], externalID [%s], origin [%s], email [%s], GUID [%s]", user.Username, user.ExternalID, user.Origin, Email(user), user.ID)
users.Add(User{
Username: user.Username,
ExternalID: user.ExternalID,
Email: Email(user),
Origin: user.Origin,
GUID: user.ID,
})
}
return users, nil
} | |
c171485 | c.ASGsToRemove)
validateASGsExist(asgConfigs, spaceConfig.ASGs, &errorString)
updateSpaceQuotaConfig(spaceConfig, c.Quota, &errorString)
if c.NamedQuota != "" {
spaceConfig.NamedQuota = c.NamedQuota
}
if c.ClearNamedQuota {
spaceConfig.NamedQuota = ""
}
c.updateUsers(spaceConfig, &errorString)
c.sshConfig(spaceConfig, &errorString)
if errorString != "" {
return errors.New(errorString)
}
if err := c.ConfigManager.SaveSpaceConfig(spaceConfig); err != nil {
return err
}
fmt.Println(fmt.Sprintf("The org/space [%s/%s] has been updated", c.OrgName, c.SpaceName))
return nil
} | |
c171486 | guid %s", plan.Name, servicePlanName, visibility.OrganizationGuid)
err := m.Client.DeleteServicePlanVisibilityByPlanAndOrg(visibility.ServicePlanGuid, visibility.OrganizationGuid, false)
if err != nil {
return err
}
}
}
}
return nil
} | |
c171487 | err := m.Client.MakeServicePlanPrivate(plan.GUID)
if err != nil {
return err
}
}
}
}
return nil
} | |
c171488 | visibilities, err := m.Client.ListServicePlanVisibilitiesByQuery(url.Values{
"q": []string{fmt.Sprintf("%s:%s", "service_plan_guid", plan.Guid)},
})
if err != nil {
return nil, err
}
for _, visibility := range visibilities {
servicePlanInfo.AddOrg(visibility.OrganizationGuid, visibility)
}
}
}
return serviceInfo, nil
} | |
c171489 | c.Peek); err == nil {
err = cfMgmt.OrgManager.CreateOrgs()
}
return err
} | |
c171490 | c.Peek); err == nil {
err = cfMgmt.OrgManager.UpdateOrgsMetadata()
}
return err
} | |
c171491 | }
fmt.Printf("The org %s was successfully deleted", c.OrgName)
return nil
} | |
c171492 |
}
fmt.Printf("The org/space %s/%s was successfully deleted", c.OrgName, c.SpaceName)
return nil
} | |
c171493 | c.Peek); err == nil {
err = cfMgmt.SpaceManager.DeleteSpaces()
}
return err
} | |
c171494 | (interface{}, error) {
return key, nil
})
} | |
c171495 |
expectedClaims: jwt.Expected{Issuer: issuer, Audience: audience},
signIn: method,
}
} | |
c171496 |
expectedClaims: jwt.Expected{Issuer: issuer, Audience: audience},
}
} | |
c171497 | extractor = RequestTokenExtractorFunc(FromHeader)
}
return &JWTValidator{config, extractor}
} | |
c171498 | v.validateRequestWithLeeway(r, jwt.DefaultLeeway)
} | |
c171499 | time.Duration) (*jwt.JSONWebToken, error) {
return v.validateRequestWithLeeway(r, leeway)
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.