_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q171400 | SetBarGap | validation | func (b *BarChart) SetBarGap(gap int32) {
atomic.StoreInt32(&b.gap, gap)
} | go | {
"resource": ""
} |
q171401 | SetMinBarWidth | validation | func (b *BarChart) SetMinBarWidth(size int32) {
atomic.StoreInt32(&b.barWidth, size)
} | go | {
"resource": ""
} |
q171402 | SetShowTitles | validation | func (b *BarChart) SetShowTitles(show bool) {
b.mtx.Lock()
defer b.mtx.Unlock()
b.showTitles = show
} | go | {
"resource": ""
} |
q171403 | SetLegendWidth | validation | func (b *BarChart) SetLegendWidth(width int32) {
atomic.StoreInt32(&b.legendWidth, width)
} | go | {
"resource": ""
} |
q171404 | OnDrawCell | validation | func (b *BarChart) OnDrawCell(fn func(*BarDataCell)) {
b.mtx.Lock()
defer b.mtx.Unlock()
b.onDrawCell = fn
} | go | {
"resource": ""
} |
q171405 | SetShowMarks | validation | func (b *BarChart) SetShowMarks(show bool) {
b.mtx.Lock()
defer b.mtx.Unlock()
b.showMarks = show
} | go | {
"resource": ""
} |
q171406 | OnKeyDown | validation | func (w *Window) OnKeyDown(fn func(Event, interface{}) bool, data interface{}) {
if fn == nil {
w.onKeyDown = nil
} else {
w.onKeyDown = &keyDownCb{data: data, fn: fn}
}
} | go | {
"resource": ""
} |
q171407 | SetMaximized | validation | func (w *Window) SetMaximized(maximize bool) {
if maximize == w.maximized {
return
}
if maximize {
w.origX, w.origY = w.Pos()
w.origWidth, w.origHeight = w.Size()
w.maximized = true
w.SetPos(0, 0)
width, height := ScreenSize()
w.SetSize(width, height)
} else {
w.maximized = false
w.SetPos(w.origX... | go | {
"resource": ""
} |
q171408 | SetVisible | validation | func (w *Window) SetVisible(visible bool) {
if w.hidden == visible {
w.hidden = !visible
if w.hidden {
w.SetModal(false)
if WindowManager().topWindow() == w {
WindowManager().moveActiveWindowToBottom()
}
} else {
WindowManager().activateWindow(w)
}
}
} | go | {
"resource": ""
} |
q171409 | SetTop | validation | func (b *SparkChart) SetTop(top float64) {
b.mtx.Lock()
defer b.mtx.Unlock()
b.topValue = top
} | go | {
"resource": ""
} |
q171410 | SetAutoScale | validation | func (b *SparkChart) SetAutoScale(auto bool) {
b.mtx.Lock()
defer b.mtx.Unlock()
b.autosize = auto
} | go | {
"resource": ""
} |
q171411 | SetHilitePeaks | validation | func (b *SparkChart) SetHilitePeaks(hilite bool) {
b.mtx.Lock()
defer b.mtx.Unlock()
b.hiliteMax = hilite
} | go | {
"resource": ""
} |
q171412 | loadEnv | validation | func loadEnv() {
gil.Lock()
defer gil.Unlock()
if os.Getenv("GO_ENV") == "" {
// if the flag "test.v" is *defined*, we're running as a unit test. Note that we don't care
// about v.Value (verbose test mode); we just want to know if the test environment has defined
// it. It's also possible that the flags are ... | go | {
"resource": ""
} |
q171413 | Get | validation | func Get(key string, value string) string {
gil.RLock()
defer gil.RUnlock()
if v, ok := env[key]; ok {
return v
}
return value
} | go | {
"resource": ""
} |
q171414 | MustGet | validation | func MustGet(key string) (string, error) {
gil.RLock()
defer gil.RUnlock()
if v, ok := env[key]; ok {
return v, nil
}
return "", fmt.Errorf("could not find ENV var with %s", key)
} | go | {
"resource": ""
} |
q171415 | Set | validation | func Set(key string, value string) {
gil.Lock()
defer gil.Unlock()
env[key] = value
} | go | {
"resource": ""
} |
q171416 | MustSet | validation | func MustSet(key string, value string) error {
gil.Lock()
defer gil.Unlock()
err := os.Setenv(key, value)
if err != nil {
return err
}
env[key] = value
return nil
} | go | {
"resource": ""
} |
q171417 | GoPaths | validation | func GoPaths() []string {
gp := Get("GOPATH", "")
if runtime.GOOS == "windows" {
return strings.Split(gp, ";") // Windows uses a different separator
}
return strings.Split(gp, ":")
} | go | {
"resource": ""
} |
q171418 | CurrentModule | validation | func CurrentModule() (string, error) {
if !Mods() {
return CurrentPackage(), nil
}
moddata, err := ioutil.ReadFile("go.mod")
if err != nil {
return "", errors.New("go.mod cannot be read or does not exist while go module is enabled")
}
packagePath := modfile.ModulePath(moddata)
if packagePath == "" {
return... | go | {
"resource": ""
} |
q171419 | request | validation | func request(client *http.Client, method, url string, body []byte) ([]byte, error) {
req, err := http.NewRequest(method, url, bytes.NewBuffer(body))
req.Header.Set("Content-Type", "application/json")
resp, err := client.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
return processResponse(re... | go | {
"resource": ""
} |
q171420 | validate | validation | func (pn *notificationRequest) validate() error {
if 0 == len(pn.Interests) || len(pn.Interests) > 10 {
return errors.New("Interests must contain between 1 and 10 interests")
}
if pn.APNS == nil && pn.GCM == nil && pn.FCM == nil {
return errors.New("PushNotification must contain a GCM, FCM or APNS payload")
}
... | go | {
"resource": ""
} |
q171421 | NewNetworkNumber | validation | func NewNetworkNumber(ip net.IP) NetworkNumber {
if ip == nil {
return nil
}
coercedIP := ip.To4()
parts := 1
if coercedIP == nil {
coercedIP = ip.To16()
parts = 4
}
if coercedIP == nil {
return nil
}
nn := make(NetworkNumber, parts)
for i := 0; i < parts; i++ {
idx := i * net.IPv4len
nn[i] = bina... | go | {
"resource": ""
} |
q171422 | ToIP | validation | func (n NetworkNumber) ToIP() net.IP {
ip := make(net.IP, len(n)*BytePerUint32)
for i := 0; i < len(n); i++ {
idx := i * net.IPv4len
binary.BigEndian.PutUint32(ip[idx:idx+net.IPv4len], n[i])
}
if len(ip) == net.IPv4len {
ip = net.IPv4(ip[0], ip[1], ip[2], ip[3])
}
return ip
} | go | {
"resource": ""
} |
q171423 | Equal | validation | func (n NetworkNumber) Equal(n1 NetworkNumber) bool {
if len(n) != len(n1) {
return false
}
if n[0] != n1[0] {
return false
}
if len(n) == IPv6Uint32Count {
return n[1] == n1[1] && n[2] == n1[2] && n[3] == n1[3]
}
return true
} | go | {
"resource": ""
} |
q171424 | Next | validation | func (n NetworkNumber) Next() NetworkNumber {
newIP := make(NetworkNumber, len(n))
copy(newIP, n)
for i := len(newIP) - 1; i >= 0; i-- {
newIP[i]++
if newIP[i] > 0 {
break
}
}
return newIP
} | go | {
"resource": ""
} |
q171425 | Previous | validation | func (n NetworkNumber) Previous() NetworkNumber {
newIP := make(NetworkNumber, len(n))
copy(newIP, n)
for i := len(newIP) - 1; i >= 0; i-- {
newIP[i]--
if newIP[i] < math.MaxUint32 {
break
}
}
return newIP
} | go | {
"resource": ""
} |
q171426 | NewNetwork | validation | func NewNetwork(ipNet net.IPNet) Network {
return Network{
IPNet: ipNet,
Number: NewNetworkNumber(ipNet.IP),
Mask: NetworkNumberMask(NewNetworkNumber(net.IP(ipNet.Mask))),
}
} | go | {
"resource": ""
} |
q171427 | Masked | validation | func (n Network) Masked(ones int) Network {
mask := net.CIDRMask(ones, len(n.Number)*BitsPerUint32)
return NewNetwork(net.IPNet{
IP: n.IP.Mask(mask),
Mask: mask,
})
} | go | {
"resource": ""
} |
q171428 | Contains | validation | func (n Network) Contains(nn NetworkNumber) bool {
if len(n.Mask) != len(nn) {
return false
}
if nn[0]&n.Mask[0] != n.Number[0] {
return false
}
if len(nn) == IPv6Uint32Count {
return nn[1]&n.Mask[1] == n.Number[1] && nn[2]&n.Mask[2] == n.Number[2] && nn[3]&n.Mask[3] == n.Number[3]
}
return true
} | go | {
"resource": ""
} |
q171429 | Covers | validation | func (n Network) Covers(o Network) bool {
if len(n.Number) != len(o.Number) {
return false
}
nMaskSize, _ := n.IPNet.Mask.Size()
oMaskSize, _ := o.IPNet.Mask.Size()
return n.Contains(o.Number) && nMaskSize <= oMaskSize
} | go | {
"resource": ""
} |
q171430 | LeastCommonBitPosition | validation | func (n Network) LeastCommonBitPosition(n1 Network) (uint, error) {
maskSize, _ := n.IPNet.Mask.Size()
if maskSize1, _ := n1.IPNet.Mask.Size(); maskSize1 < maskSize {
maskSize = maskSize1
}
maskPosition := len(n1.Number)*BitsPerUint32 - maskSize
lcb, err := n.Number.LeastCommonBitPosition(n1.Number)
if err != n... | go | {
"resource": ""
} |
q171431 | Equal | validation | func (n Network) Equal(n1 Network) bool {
return n.String() == n1.String()
} | go | {
"resource": ""
} |
q171432 | Mask | validation | func (m NetworkNumberMask) Mask(n NetworkNumber) (NetworkNumber, error) {
if len(m) != len(n) {
return nil, ErrVersionMismatch
}
result := make(NetworkNumber, len(m))
result[0] = m[0] & n[0]
if len(m) == IPv6Uint32Count {
result[1] = m[1] & n[1]
result[2] = m[2] & n[2]
result[3] = m[3] & n[3]
}
return re... | go | {
"resource": ""
} |
q171433 | NextIP | validation | func NextIP(ip net.IP) net.IP {
return NewNetworkNumber(ip).Next().ToIP()
} | go | {
"resource": ""
} |
q171434 | PreviousIP | validation | func PreviousIP(ip net.IP) net.IP {
return NewNetworkNumber(ip).Previous().ToIP()
} | go | {
"resource": ""
} |
q171435 | newPrefixTree | validation | func newPrefixTree(version rnet.IPVersion) Ranger {
_, rootNet, _ := net.ParseCIDR("0.0.0.0/0")
if version == rnet.IPv6 {
_, rootNet, _ = net.ParseCIDR("0::0/0")
}
return &prefixTrie{
children: make([]*prefixTrie, 2, 2),
numBitsSkipped: 0,
numBitsHandled: 1,
network: rnet.NewNetwork(*rootNet)... | go | {
"resource": ""
} |
q171436 | Insert | validation | func (p *prefixTrie) Insert(entry RangerEntry) error {
network := entry.Network()
return p.insert(rnet.NewNetwork(network), entry)
} | go | {
"resource": ""
} |
q171437 | Remove | validation | func (p *prefixTrie) Remove(network net.IPNet) (RangerEntry, error) {
return p.remove(rnet.NewNetwork(network))
} | go | {
"resource": ""
} |
q171438 | Contains | validation | func (p *prefixTrie) Contains(ip net.IP) (bool, error) {
nn := rnet.NewNetworkNumber(ip)
if nn == nil {
return false, ErrInvalidNetworkNumberInput
}
return p.contains(nn)
} | go | {
"resource": ""
} |
q171439 | String | validation | func (p *prefixTrie) String() string {
children := []string{}
padding := strings.Repeat("| ", p.level()+1)
for bits, child := range p.children {
if child == nil {
continue
}
childStr := fmt.Sprintf("\n%s%d--> %s", padding, bits, child.String())
children = append(children, childStr)
}
return fmt.Sprintf(... | go | {
"resource": ""
} |
q171440 | walkDepth | validation | func (p *prefixTrie) walkDepth() <-chan RangerEntry {
entries := make(chan RangerEntry)
go func() {
if p.hasEntry() {
entries <- p.entry
}
childEntriesList := []<-chan RangerEntry{}
for _, trie := range p.children {
if trie == nil {
continue
}
childEntriesList = append(childEntriesList, trie.w... | go | {
"resource": ""
} |
q171441 | newBruteRanger | validation | func newBruteRanger() Ranger {
return &bruteRanger{
ipV4Entries: make(map[string]RangerEntry),
ipV6Entries: make(map[string]RangerEntry),
}
} | go | {
"resource": ""
} |
q171442 | Insert | validation | func (b *bruteRanger) Insert(entry RangerEntry) error {
network := entry.Network()
key := network.String()
if _, found := b.ipV4Entries[key]; !found {
entries, err := b.getEntriesByVersion(entry.Network().IP)
if err != nil {
return err
}
entries[key] = entry
}
return nil
} | go | {
"resource": ""
} |
q171443 | Remove | validation | func (b *bruteRanger) Remove(network net.IPNet) (RangerEntry, error) {
networks, err := b.getEntriesByVersion(network.IP)
if err != nil {
return nil, err
}
key := network.String()
if networkToDelete, found := networks[key]; found {
delete(networks, key)
return networkToDelete, nil
}
return nil, nil
} | go | {
"resource": ""
} |
q171444 | Contains | validation | func (b *bruteRanger) Contains(ip net.IP) (bool, error) {
entries, err := b.getEntriesByVersion(ip)
if err != nil {
return false, err
}
for _, entry := range entries {
network := entry.Network()
if network.Contains(ip) {
return true, nil
}
}
return false, nil
} | go | {
"resource": ""
} |
q171445 | ParseMessage | validation | func ParseMessage(line string) Message {
// Uncomment this and recoverMessage if debugging a message that crashes the parser
//defer recoverMessage(line)
ircMessage, err := parseIRCMessage(line)
if err != nil {
return parseRawMessage(ircMessage)
}
if mt, ok := messageTypeMap[ircMessage.Command]; ok {
return... | go | {
"resource": ""
} |
q171446 | NewClient | validation | func NewClient(username, oauth string) *Client {
return &Client{
ircUser: username,
ircToken: oauth,
TLS: true,
channels: map[string]bool{},
channelUserlist: map[string]map[string]bool{},
channelsMtx: &sync.RWMutex{},
messageReceived: make(chan bool),
read: make(... | go | {
"resource": ""
} |
q171447 | Say | validation | func (c *Client) Say(channel, text string) {
channel = strings.ToLower(channel)
c.send(fmt.Sprintf("PRIVMSG #%s :%s", channel, text))
} | go | {
"resource": ""
} |
q171448 | Whisper | validation | func (c *Client) Whisper(username, text string) {
c.send(fmt.Sprintf("PRIVMSG #%s :/w %s %s", c.ircUser, username, text))
} | go | {
"resource": ""
} |
q171449 | Join | validation | func (c *Client) Join(channel string) {
channel = strings.ToLower(channel)
// If we don't have the channel in our map AND we have an
// active connection, explicitly join before we add it to our map
c.channelsMtx.Lock()
if !c.channels[channel] && c.connActive.get() {
go c.send(fmt.Sprintf("JOIN #%s", channel))
... | go | {
"resource": ""
} |
q171450 | Depart | validation | func (c *Client) Depart(channel string) {
if c.connActive.get() {
go c.send(fmt.Sprintf("PART #%s", channel))
}
c.channelsMtx.Lock()
delete(c.channels, channel)
c.channelUserlistMutex.Lock()
delete(c.channelUserlist, channel)
c.channelUserlistMutex.Unlock()
c.channelsMtx.Unlock()
} | go | {
"resource": ""
} |
q171451 | Disconnect | validation | func (c *Client) Disconnect() error {
if !c.connActive.get() {
return ErrConnectionIsNotOpen
}
c.userDisconnect.Close()
return nil
} | go | {
"resource": ""
} |
q171452 | Connect | validation | func (c *Client) Connect() error {
if c.IrcAddress == "" && c.TLS {
c.IrcAddress = ircTwitchTLS
} else if c.IrcAddress == "" && !c.TLS {
c.IrcAddress = ircTwitch
}
dialer := &net.Dialer{
KeepAlive: time.Second * 10,
}
var conf *tls.Config
// This means we are connecting to "localhost". Disable certificat... | go | {
"resource": ""
} |
q171453 | Userlist | validation | func (c *Client) Userlist(channel string) ([]string, error) {
c.channelUserlistMutex.RLock()
defer c.channelUserlistMutex.RUnlock()
usermap, ok := c.channelUserlist[channel]
if !ok || usermap == nil {
return nil, fmt.Errorf("Could not find userlist for channel '%s' in client", channel)
}
userlist := make([]stri... | go | {
"resource": ""
} |
q171454 | handleLine | validation | func (c *Client) handleLine(line string) error {
go func() {
// Send a message on the `messageReceived` channel, but do not block in case no one is receiving on the other end
select {
case c.messageReceived <- true:
default:
}
}()
message := ParseMessage(line)
switch msg := message.(type) {
case *Whisp... | go | {
"resource": ""
} |
q171455 | Execute | validation | func (c *GenerateConcoursePipelineCommand) Execute([]string) error {
lo.G.Warning("This command has been deprecated use lastest cf-mgmt-config cli")
const varsFileName = "vars.yml"
const pipelineFileName = "pipeline.yml"
const cfMgmtYml = "cf-mgmt.yml"
const cfMgmtSh = "cf-mgmt.sh"
var targetFile string
fmt.Prin... | go | {
"resource": ""
} |
q171456 | Execute | validation | func (c *CleanupOrgUsersCommand) Execute([]string) error {
if cfMgmt, err := InitializePeekManagers(c.BaseCFConfigCommand, c.Peek); err == nil {
return cfMgmt.UserManager.CleanupOrgUsers()
}
return nil
} | go | {
"resource": ""
} |
q171457 | classify | validation | func classify(desired []cfclient.IsolationSegment, current []cfclient.IsolationSegment) classification {
currentSegments := make(map[string]*cfclient.IsolationSegment)
for i := range current {
currentSegments[current[i].Name] = ¤t[i]
}
desiredSegments := make(map[string]*cfclient.IsolationSegment)
for i :=... | go | {
"resource": ""
} |
q171458 | Execute | validation | func (c *CreateSpaceSecurityGroupsCommand) Execute([]string) error {
var cfMgmt *CFMgmt
var err error
if cfMgmt, err = InitializePeekManagers(c.BaseCFConfigCommand, c.Peek); err == nil {
err = cfMgmt.SecurityGroupManager.CreateApplicationSecurityGroups()
}
return err
} | go | {
"resource": ""
} |
q171459 | Execute | validation | func (c *UpdateSpacesMetadataCommand) Execute([]string) error {
var cfMgmt *CFMgmt
var err error
if cfMgmt, err = InitializePeekManagers(c.BaseCFConfigCommand, c.Peek); err == nil {
err = cfMgmt.SpaceManager.UpdateSpacesMetadata()
}
return err
} | go | {
"resource": ""
} |
q171460 | Execute | validation | func (c *SpaceNamedQuotaConfigurationCommand) Execute(args []string) error {
c.initConfig()
spaceQuota, err := c.ConfigManager.GetSpaceQuota(c.Name, c.Org)
if err != nil {
return err
}
if spaceQuota == nil {
spaceQuota = &config.SpaceQuota{
Name: c.Name,
Org: c.Org,... | go | {
"resource": ""
} |
q171461 | Execute | validation | func (c *AddASGToConfigurationCommand) Execute([]string) error {
c.initConfig()
errorString := ""
if errorString != "" {
return errors.New(errorString)
}
if !c.Override {
if c.ASGType == "space" {
asgConfigs, err := c.ConfigManager.GetASGConfigs()
if err != nil {
return err
}
for _, asgConfi... | go | {
"resource": ""
} |
q171462 | Execute | validation | func (c *UpdateSpaceUsersCommand) Execute([]string) error {
if cfMgmt, err := InitializePeekManagers(c.BaseCFConfigCommand, c.Peek); err == nil {
if err := cfMgmt.UserManager.InitializeLdap(c.LdapUser, c.LdapPassword, c.LdapServer); err != nil {
return err
}
defer cfMgmt.UserManager.DeinitializeLdap()
retur... | go | {
"resource": ""
} |
q171463 | Execute | validation | func (c *DeleteOrgsCommand) Execute([]string) error {
var cfMgmt *CFMgmt
var err error
if cfMgmt, err = InitializePeekManagers(c.BaseCFConfigCommand, c.Peek); err == nil {
err = cfMgmt.OrgManager.DeleteOrgs()
}
return err
} | go | {
"resource": ""
} |
q171464 | Execute | validation | func (c *OrgNamedQuotaConfigurationCommand) Execute(args []string) error {
c.initConfig()
orgQuota, err := c.ConfigManager.GetOrgQuota(c.Name)
if err != nil {
return err
}
if orgQuota == nil {
orgQuota = &config.OrgQuota{
Name: c.Name,
TotalPrivateDomains: "unlimited",
TotalRese... | go | {
"resource": ""
} |
q171465 | Contains | validation | func (s *Spaces) Contains(spaceName string) bool {
spaceNameToUpper := strings.ToUpper(spaceName)
for _, v := range s.Spaces {
if strings.ToUpper(v) == spaceNameToUpper {
return true
}
}
return false
} | go | {
"resource": ""
} |
q171466 | Execute | validation | func (c *UpdateOrgQuotasCommand) Execute([]string) error {
var cfMgmt *CFMgmt
var err error
if cfMgmt, err = InitializePeekManagers(c.BaseCFConfigCommand, c.Peek); err == nil {
err = cfMgmt.QuotaManager.CreateOrgQuotas()
}
return err
} | go | {
"resource": ""
} |
q171467 | Execute | validation | func (c *UpdateSpaceQuotasCommand) Execute([]string) error {
var cfMgmt *CFMgmt
var err error
if cfMgmt, err = InitializePeekManagers(c.BaseCFConfigCommand, c.Peek); err == nil {
err = cfMgmt.QuotaManager.CreateSpaceQuotas()
}
return err
} | go | {
"resource": ""
} |
q171468 | Orgs | validation | func (m *yamlManager) Orgs() (*Orgs, error) {
configFile := filepath.Join(m.ConfigDir, "orgs.yml")
lo.G.Debug("Processing org file", configFile)
input := &Orgs{}
if err := LoadFile(configFile, &input); err != nil {
return nil, err
}
return input, nil
} | go | {
"resource": ""
} |
q171469 | GetGlobalConfig | validation | func (m *yamlManager) GetGlobalConfig() (*GlobalConfig, error) {
globalConfig := &GlobalConfig{}
LoadFile(path.Join(m.ConfigDir, "cf-mgmt.yml"), globalConfig)
if len(globalConfig.MetadataPrefix) == 0 {
globalConfig.MetadataPrefix = "cf-mgmt.pivotal.io"
}
return globalConfig, nil
} | go | {
"resource": ""
} |
q171470 | GetOrgConfigs | validation | func (m *yamlManager) GetOrgConfigs() ([]OrgConfig, error) {
files, err := FindFiles(m.ConfigDir, "orgConfig.yml")
if err != nil {
return nil, err
}
result := make([]OrgConfig, len(files))
for i, f := range files {
result[i].AppTaskLimit = unlimited
result[i].AppInstanceLimit = unlimited
result[i].TotalRes... | go | {
"resource": ""
} |
q171471 | GetSpaceDefaults | validation | func (m *yamlManager) GetSpaceDefaults() (*SpaceConfig, error) {
fp := filepath.Join(m.ConfigDir, "spaceDefaults.yml")
if !FileOrDirectoryExists(fp) {
return nil, nil
}
result := SpaceConfig{}
err := LoadFile(fp, &result)
return &result, err
} | go | {
"resource": ""
} |
q171472 | AddOrgToConfig | validation | func (m *yamlManager) AddOrgToConfig(orgConfig *OrgConfig, spaces *Spaces) error {
orgList, err := m.Orgs()
if err != nil {
return err
}
orgName := orgConfig.Org
if orgName == "" {
return errors.New("cannot have an empty org name")
}
if orgList.Contains(orgName) {
return fmt.Errorf("org [%s] already added... | go | {
"resource": ""
} |
q171473 | AddSpaceToConfig | validation | func (m *yamlManager) AddSpaceToConfig(spaceConfig *SpaceConfig) error {
orgName := spaceConfig.Org
spaceFileName := filepath.Join(m.ConfigDir, orgName, "spaces.yml")
spaceList := &Spaces{}
spaceName := spaceConfig.Space
if err := LoadFile(spaceFileName, spaceList); err != nil {
return err
}
if spaceList.Cont... | go | {
"resource": ""
} |
q171474 | CreateConfigIfNotExists | validation | func (m *yamlManager) CreateConfigIfNotExists(uaaOrigin string) error {
if FileOrDirectoryExists(m.ConfigDir) {
lo.G.Infof("Config directory %s already exists, skipping creation", m.ConfigDir)
return nil
}
if err := os.MkdirAll(m.ConfigDir, 0755); err != nil {
lo.G.Errorf("Error creating config directory %s. E... | go | {
"resource": ""
} |
q171475 | DeleteConfigIfExists | validation | func (m *yamlManager) DeleteConfigIfExists() error {
if !FileOrDirectoryExists(m.ConfigDir) {
lo.G.Infof("%s doesn't exists, nothing to delete", m.ConfigDir)
return nil
}
if err := os.RemoveAll(m.ConfigDir); err != nil {
lo.G.Errorf("Error deleting config folder. Error: %s", err)
return fmt.Errorf("cannot de... | go | {
"resource": ""
} |
q171476 | Execute | validation | func (c *RenameSpaceConfigurationCommand) Execute(args []string) error {
c.initConfig()
spaceConfig, err := c.ConfigManager.GetSpaceConfig(c.OrgName, c.SpaceName)
if err != nil {
return err
}
spaces, err := c.ConfigManager.OrgSpaces(c.OrgName)
if err != nil {
return err
}
spaceConfig.Space = c.NewSpaceName... | go | {
"resource": ""
} |
q171477 | Execute | validation | func (c *CreateSpacesCommand) Execute([]string) error {
var cfMgmt *CFMgmt
var err error
if cfMgmt, err = InitializePeekManagers(c.BaseCFConfigCommand, c.Peek); err == nil {
err = cfMgmt.SpaceManager.CreateSpaces()
}
return err
} | go | {
"resource": ""
} |
q171478 | DeleteSpace | validation | func (m *DefaultManager) DeleteSpace(space cfclient.Space, orgName string) error {
if m.Peek {
lo.G.Infof("[dry-run]: delete space 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)
} | go | {
"resource": ""
} |
q171479 | NewExportManager | validation | func NewExportManager(
configDir string,
uaaMgr uaa.Manager,
spaceManager space.Manager,
userManager user.Manager,
orgManager organization.Manager,
securityGroupManager securitygroup.Manager,
isoSegmentMgr isosegment.Manager,
privateDomainMgr privatedomain.Manager,
sharedDomainMgr *shareddomain.Manager,
servi... | go | {
"resource": ""
} |
q171480 | Contains | validation | func (o *Orgs) Contains(orgName string) bool {
orgNameUpper := strings.ToUpper(orgName)
for _, org := range o.Orgs {
if strings.ToUpper(org) == orgNameUpper {
return true
}
}
return false
} | go | {
"resource": ""
} |
q171481 | UpdateOrgs | validation | func (u *Updater) UpdateOrgs() error {
ocs, err := u.Cfg.GetOrgConfigs()
if err != nil {
return err
}
for _, oc := range ocs {
org, err := u.OrgManager.FindOrg(oc.Org)
if err != nil {
return errors.Wrap(err, "finding org for org configs in update orgs")
}
isolationSegmentMap, err := u.isolationSegmentM... | go | {
"resource": ""
} |
q171482 | UpdateSpaces | validation | func (u *Updater) UpdateSpaces() error {
scs, err := u.Cfg.GetSpaceConfigs()
if err != nil {
return err
}
isolationSegmentMap, err := u.isolationSegmentMap()
if err != nil {
return err
}
for _, sc := range scs {
space, err := u.SpaceManager.FindSpace(sc.Org, sc.Space)
if err != nil {
return err
}
... | go | {
"resource": ""
} |
q171483 | allDesiredSegments | validation | func (u *Updater) allDesiredSegments() ([]cfclient.IsolationSegment, error) {
orgs, err := u.Cfg.GetOrgConfigs()
if err != nil {
return nil, err
}
spaces, err := u.Cfg.GetSpaceConfigs()
if err != nil {
return nil, err
}
segments := make(map[string]struct{})
for _, org := range orgs {
if org.DefaultIsoSeg... | go | {
"resource": ""
} |
q171484 | ListUsers | validation | func (m *DefaultUAAManager) ListUsers() (*Users, error) {
users := &Users{}
lo.G.Debug("Getting users from Cloud Foundry")
userList, err := m.Client.ListAllUsers("", "", "userName,id,externalId,emails,origin", "")
if err != nil {
return nil, err
}
lo.G.Debugf("Found %d users in the CF instance", len(userList))... | go | {
"resource": ""
} |
q171485 | Execute | validation | func (c *UpdateSpaceConfigurationCommand) Execute(args []string) error {
c.initConfig()
spaceConfig, err := c.ConfigManager.GetSpaceConfig(c.OrgName, c.SpaceName)
if err != nil {
return err
}
asgConfigs, err := c.ConfigManager.GetASGConfigs()
if err != nil {
return err
}
if c.Quota.EnableSpaceQuota == "tru... | go | {
"resource": ""
} |
q171486 | RemoveUnknownVisibilites | validation | func (m *Manager) RemoveUnknownVisibilites(serviceInfo *ServiceInfo) error {
for servicePlanName, servicePlan := range serviceInfo.AllPlans() {
for _, plan := range servicePlan {
for _, visibility := range plan.ListVisibilities() {
if m.Peek {
lo.G.Infof("[dry-run]: removing plan %s for service %s to org... | go | {
"resource": ""
} |
q171487 | DisablePublicServiceAccess | validation | func (m *Manager) DisablePublicServiceAccess(serviceInfo *ServiceInfo) error {
for _, servicePlan := range serviceInfo.AllPlans() {
for _, plan := range servicePlan {
if plan.Public {
err := m.Client.MakeServicePlanPrivate(plan.GUID)
if err != nil {
return err
}
}
}
}
return nil
} | go | {
"resource": ""
} |
q171488 | ListServiceInfo | validation | func (m *Manager) ListServiceInfo() (*ServiceInfo, error) {
serviceInfo := &ServiceInfo{}
services, err := m.Client.ListServices()
if err != nil {
return nil, err
}
for _, service := range services {
plans, err := m.Client.ListServicePlansByQuery(url.Values{
"q": []string{fmt.Sprintf("%s:%s", "service_guid"... | go | {
"resource": ""
} |
q171489 | Execute | validation | func (c *CreateOrgsCommand) Execute([]string) error {
var cfMgmt *CFMgmt
var err error
if cfMgmt, err = InitializePeekManagers(c.BaseCFConfigCommand, c.Peek); err == nil {
err = cfMgmt.OrgManager.CreateOrgs()
}
return err
} | go | {
"resource": ""
} |
q171490 | Execute | validation | func (c *UpdateOrgsMetadataCommand) Execute([]string) error {
var cfMgmt *CFMgmt
var err error
if cfMgmt, err = InitializePeekManagers(c.BaseCFConfigCommand, c.Peek); err == nil {
err = cfMgmt.OrgManager.UpdateOrgsMetadata()
}
return err
} | go | {
"resource": ""
} |
q171491 | Execute | validation | func (c *DeleteOrgConfigurationCommand) Execute([]string) error {
if err := config.NewManager(c.ConfigDirectory).DeleteOrgConfig(c.OrgName); err != nil {
return err
}
fmt.Printf("The org %s was successfully deleted", c.OrgName)
return nil
} | go | {
"resource": ""
} |
q171492 | Execute | validation | func (c *DeleteSpaceConfigurationCommand) Execute([]string) error {
if err := config.NewManager(c.ConfigDirectory).DeleteSpaceConfig(c.OrgName, c.SpaceName); err != nil {
return err
}
fmt.Printf("The org/space %s/%s was successfully deleted", c.OrgName, c.SpaceName)
return nil
} | go | {
"resource": ""
} |
q171493 | Execute | validation | func (c *DeleteSpacesCommand) Execute([]string) error {
var cfMgmt *CFMgmt
var err error
if cfMgmt, err = InitializePeekManagers(c.BaseCFConfigCommand, c.Peek); err == nil {
err = cfMgmt.SpaceManager.DeleteSpaces()
}
return err
} | go | {
"resource": ""
} |
q171494 | NewKeyProvider | validation | func NewKeyProvider(key interface{}) SecretProvider {
return SecretProviderFunc(func(_ *http.Request) (interface{}, error) {
return key, nil
})
} | go | {
"resource": ""
} |
q171495 | NewConfiguration | validation | func NewConfiguration(provider SecretProvider, audience []string, issuer string, method jose.SignatureAlgorithm) Configuration {
return Configuration{
secretProvider: provider,
expectedClaims: jwt.Expected{Issuer: issuer, Audience: audience},
signIn: method,
}
} | go | {
"resource": ""
} |
q171496 | NewConfigurationTrustProvider | validation | func NewConfigurationTrustProvider(provider SecretProvider, audience []string, issuer string) Configuration {
return Configuration{
secretProvider: provider,
expectedClaims: jwt.Expected{Issuer: issuer, Audience: audience},
}
} | go | {
"resource": ""
} |
q171497 | NewValidator | validation | func NewValidator(config Configuration, extractor RequestTokenExtractor) *JWTValidator {
if extractor == nil {
extractor = RequestTokenExtractorFunc(FromHeader)
}
return &JWTValidator{config, extractor}
} | go | {
"resource": ""
} |
q171498 | ValidateRequest | validation | func (v *JWTValidator) ValidateRequest(r *http.Request) (*jwt.JSONWebToken, error) {
return v.validateRequestWithLeeway(r, jwt.DefaultLeeway)
} | go | {
"resource": ""
} |
q171499 | ValidateRequestWithLeeway | validation | func (v *JWTValidator) ValidateRequestWithLeeway(r *http.Request, leeway time.Duration) (*jwt.JSONWebToken, error) {
return v.validateRequestWithLeeway(r, leeway)
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.