_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q168200 | waitForIP | validation | func (d *Driver) waitForIP() (string, error) {
log.Infof("Waiting for host to start...")
for {
ip, _ := d.GetIP()
if ip != "" {
return ip, nil
}
time.Sleep(1 * time.Second)
}
} | go | {
"resource": ""
} |
q168201 | waitStopped | validation | func (d *Driver) waitStopped() error {
log.Infof("Waiting for host to stop...")
for {
s, err := d.GetState()
if err != nil {
return err
}
if s != state.Running {
return nil
}
time.Sleep(1 * time.Second)
}
} | go | {
"resource": ""
} |
q168202 | Start | validation | func (d *Driver) Start() error {
if err := cmd("Hyper-V\\Start-VM", d.MachineName); err != nil {
return err
}
ip, err := d.waitForIP()
if err != nil {
return err
}
d.IPAddress = ip
return nil
} | go | {
"resource": ""
} |
q168203 | Stop | validation | func (d *Driver) Stop() error {
if err := cmd("Hyper-V\\Stop-VM", d.MachineName); err != nil {
return err
}
if err := d.waitStopped(); err != nil {
return err
}
d.IPAddress = ""
return nil
} | go | {
"resource": ""
} |
q168204 | Remove | validation | func (d *Driver) Remove() error {
s, err := d.GetState()
if err != nil {
return err
}
if s == state.Running {
if err := d.Kill(); err != nil {
return err
}
}
return cmd("Hyper-V\\Remove-VM", d.MachineName, "-Force")
} | go | {
"resource": ""
} |
q168205 | generateDiskImage | validation | func (d *Driver) generateDiskImage() (string, error) {
diskImage := d.ResolveStorePath("disk.vhd")
fixed := d.ResolveStorePath("fixed.vhd")
// Resizing vhds requires administrator privileges
// incase the user is only a hyper-v admin then create the disk at the target size to avoid resizing.
isWindowsAdmin, err :... | go | {
"resource": ""
} |
q168206 | GetIP | validation | func (d *BaseDriver) GetIP() (string, error) {
if d.IPAddress == "" {
return "", errors.New("IP address is not set")
}
return d.IPAddress, nil
} | go | {
"resource": ""
} |
q168207 | GetSSHKeyPath | validation | func (d *BaseDriver) GetSSHKeyPath() string {
if d.SSHKeyPath == "" {
d.SSHKeyPath = d.ResolveStorePath("id_rsa")
}
return d.SSHKeyPath
} | go | {
"resource": ""
} |
q168208 | GetSSHPort | validation | func (d *BaseDriver) GetSSHPort() (int, error) {
if d.SSHPort == 0 {
d.SSHPort = DefaultSSHPort
}
return d.SSHPort, nil
} | go | {
"resource": ""
} |
q168209 | GetSSHUsername | validation | func (d *BaseDriver) GetSSHUsername() string {
if d.SSHUser == "" {
d.SSHUser = DefaultSSHUser
}
return d.SSHUser
} | go | {
"resource": ""
} |
q168210 | ResolveStorePath | validation | func (d *BaseDriver) ResolveStorePath(file string) string {
return filepath.Join(d.StorePath, "machines", d.MachineName, file)
} | go | {
"resource": ""
} |
q168211 | SetSwarmConfigFromFlags | validation | func (d *BaseDriver) SetSwarmConfigFromFlags(flags DriverOptions) {
d.SwarmMaster = flags.Bool("swarm-master")
d.SwarmHost = flags.String("swarm-host")
d.SwarmDiscovery = flags.String("swarm-discovery")
} | go | {
"resource": ""
} |
q168212 | IsVTXDisabledInTheVM | validation | func (d *Driver) IsVTXDisabledInTheVM() (bool, error) {
lines, err := d.readVBoxLog()
if err != nil {
return true, err
}
for _, line := range lines {
if strings.Contains(line, "VT-x is disabled") && !strings.Contains(line, "Falling back to raw-mode: VT-x is disabled in the BIOS for all CPU modes") {
return ... | go | {
"resource": ""
} |
q168213 | getReleaseTag | validation | func (*b2dReleaseGetter) getReleaseTag(apiURL string) (string, error) {
if apiURL == "" {
apiURL = defaultURL
}
if !version.RC() {
// Just go straight to the convenience URL for "/latest" if we
// are a non-release candidate version. "/latest" won't return
// non-RCs, so that's what we use for stable relea... | go | {
"resource": ""
} |
q168214 | getReleaseURL | validation | func (b *b2dReleaseGetter) getReleaseURL(apiURL string) (string, error) {
if apiURL == "" {
apiURL = defaultURL
}
// match github (enterprise) release urls:
// https://api.github.com/repos/../../releases or
// https://some.github.enterprise/api/v3/repos/../../releases
re := regexp.MustCompile("(https?)://([^/]... | go | {
"resource": ""
} |
q168215 | version | validation | func (b *b2dISO) version() (string, error) {
if b == nil {
return "", nil
}
iso, err := os.Open(b.commonIsoPath)
if err != nil {
return "", err
}
defer iso.Close()
isoMetadata := make([]byte, b.volumeIDLength)
_, err = iso.ReadAt(isoMetadata, b.volumeIDOffset)
if err != nil {
return "", err
}
trimme... | go | {
"resource": ""
} |
q168216 | DownloadISO | validation | func (b *B2dUtils) DownloadISO(dir, file, isoURL string) error {
log.Infof("Downloading %s from %s...", b.path(), isoURL)
return b.download(dir, file, isoURL)
} | go | {
"resource": ""
} |
q168217 | Authenticate | validation | func (c *Client) Authenticate(d *openstack.Driver) error {
if c.Provider != nil {
return nil
}
log.Debug("Authenticating to Rackspace.", map[string]string{
"Username": d.Username,
})
apiKey := c.driver.APIKey
opts := gophercloud.AuthOptions{
Username: d.Username,
APIKey: apiKey,
}
provider, err := ... | go | {
"resource": ""
} |
q168218 | GetInstanceIPAddresses | validation | func (c *Client) GetInstanceIPAddresses(d *openstack.Driver) ([]openstack.IPAddress, error) {
server, err := c.GetServerDetail(d)
if err != nil {
return nil, err
}
return []openstack.IPAddress{
{
Network: "public",
Address: server.AccessIPv4,
AddressType: openstack.Fixed,
},
}, nil
} | go | {
"resource": ""
} |
q168219 | targetHost | validation | func targetHost(c CommandLine, api libmachine.API) (string, error) {
if len(c.Args()) == 0 {
defaultExists, err := api.Exists(defaultMachineName)
if err != nil {
return "", fmt.Errorf("Error checking if host %q exists: %s", defaultMachineName, err)
}
if defaultExists {
return defaultMachineName, nil
}... | go | {
"resource": ""
} |
q168220 | machineCommand | validation | func machineCommand(actionName string, host *host.Host, errorChan chan<- error) {
// TODO: These actions should have their own type.
commands := map[string](func() error){
"configureAuth": host.ConfigureAuth,
"configureAllAuth": host.ConfigureAllAuth,
"start": host.Start,
"stop": hos... | go | {
"resource": ""
} |
q168221 | runActionForeachMachine | validation | func runActionForeachMachine(actionName string, machines []*host.Host) []error {
var (
numConcurrentActions = 0
errorChan = make(chan error)
errs = []error{}
)
for _, machine := range machines {
numConcurrentActions++
go machineCommand(actionName, machine, errorChan)
}
// TOD... | go | {
"resource": ""
} |
q168222 | Create | validation | func (api *Client) Create(h *host.Host) error {
if err := cert.BootstrapCertificates(h.AuthOptions()); err != nil {
return fmt.Errorf("Error generating certificates: %s", err)
}
log.Info("Running pre-create checks...")
if err := h.Driver.PreCreateCheck(); err != nil {
return mcnerror.ErrDuringPreCreate{
Ca... | go | {
"resource": ""
} |
q168223 | GenerateRandomID | validation | func GenerateRandomID() string {
for {
id := make([]byte, 32)
if _, err := io.ReadFull(rand.Reader, id); err != nil {
panic(err) // This shouldn't happen
}
value := hex.EncodeToString(id)
// if we try to parse the truncated for as an int and we don't have
// an error then the value is all numeric and ca... | go | {
"resource": ""
} |
q168224 | GetCreateFlags | validation | func (d *Driver) GetCreateFlags() []mcnflag.Flag {
return []mcnflag.Flag{
mcnflag.StringFlag{
EnvVar: "OS_USERNAME",
Name: "rackspace-username",
Usage: "Rackspace account username",
Value: "",
},
mcnflag.StringFlag{
EnvVar: "OS_API_KEY",
Name: "rackspace-api-key",
Usage: "Rackspace AP... | go | {
"resource": ""
} |
q168225 | NewDriver | validation | func NewDriver(machineName, storePath string) drivers.Driver {
log.Debug("Instantiating Rackspace driver.", map[string]string{"machineName": machineName})
inner := openstack.NewDerivedDriver(machineName, storePath)
driver := &Driver{
Driver: inner,
}
inner.SetClient(&Client{
driver: driver,
})
return drive... | go | {
"resource": ""
} |
q168226 | SetConfigFromFlags | validation | func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
d.ActiveTimeout = flags.Int("rackspace-active-timeout")
d.Username = flags.String("rackspace-username")
d.APIKey = flags.String("rackspace-api-key")
d.Region = flags.String("rackspace-region")
d.EndpointType = flags.String("rackspace-endpoint... | go | {
"resource": ""
} |
q168227 | URL | validation | func (rd *RemoteDocker) URL() (string, error) {
if rd.HostURL == "" {
return "", fmt.Errorf("Docker Host URL not set")
}
return rd.HostURL, nil
} | go | {
"resource": ""
} |
q168228 | newAzureClient | validation | func (d *Driver) newAzureClient() (*azureutil.AzureClient, error) {
env, ok := environments[d.Environment]
if !ok {
valid := make([]string, 0, len(environments))
for k := range environments {
valid = append(valid, k)
}
return nil, fmt.Errorf("Invalid Azure environment: %q, supported values: %s", d.Environ... | go | {
"resource": ""
} |
q168229 | generateSSHKey | validation | func (d *Driver) generateSSHKey(ctx *azureutil.DeploymentContext) error {
privPath := d.GetSSHKeyPath()
pubPath := privPath + ".pub"
log.Debug("Creating SSH key...", logutil.Fields{
"pub": pubPath,
"priv": privPath,
})
if err := ssh.GenerateSSHKey(privPath); err != nil {
return err
}
log.Debug("SSH key ... | go | {
"resource": ""
} |
q168230 | parseSecurityRuleProtocol | validation | func parseSecurityRuleProtocol(proto string) (network.SecurityRuleProtocol, error) {
switch strings.ToLower(proto) {
case "tcp":
return network.TCP, nil
case "udp":
return network.UDP, nil
case "*":
return network.Asterisk, nil
default:
return "", fmt.Errorf("invalid protocol %s", proto)
}
} | go | {
"resource": ""
} |
q168231 | String | validation | func (s State) String() string {
if int(s) >= 0 && int(s) < len(states) {
return states[s]
}
return ""
} | go | {
"resource": ""
} |
q168232 | randomString | validation | func randomString(n int, alphabet string) string {
r := timeSeed()
b := make([]byte, n)
for i := range b {
b[i] = alphabet[r.Intn(len(alphabet))]
}
return string(b)
} | go | {
"resource": ""
} |
q168233 | GetCreateFlags | validation | func (d *Driver) GetCreateFlags() []mcnflag.Flag {
return []mcnflag.Flag{
mcnflag.IntFlag{
EnvVar: "VSPHERE_CPU_COUNT",
Name: "vmwarevsphere-cpu-count",
Usage: "vSphere CPU number for docker VM",
Value: defaultCpus,
},
mcnflag.IntFlag{
EnvVar: "VSPHERE_MEMORY_SIZE",
Name: "vmwarevsphere-m... | go | {
"resource": ""
} |
q168234 | generateKeyBundle | validation | func (d *Driver) generateKeyBundle() error {
log.Debugf("Creating Tar key bundle...")
magicString := "boot2docker, this is vmware speaking"
tf, err := os.Create(d.ResolveStorePath("userdata.tar"))
if err != nil {
return err
}
defer tf.Close()
var fileWriter = tf
tw := tar.NewWriter(fileWriter)
defer tw.Cl... | go | {
"resource": ""
} |
q168235 | NewDriver | validation | func NewDriver(hostName, storePath string) *Driver {
return &Driver{
VBoxManager: NewVBoxManager(),
b2dUpdater: NewB2DUpdater(),
sshKeyGenerator: NewSSHKeyGenerator(),
diskCreator: NewDiskCreator(),
logsReader: NewLogsReader(),
ipWaiter: NewIPWaiter(),
ran... | go | {
"resource": ""
} |
q168236 | PreCreateCheck | validation | func (d *Driver) PreCreateCheck() error {
// Check that VBoxManage exists and works
version, err := d.vbmOut("--version")
if err != nil {
return err
}
// Check that VBoxManage is of a supported version
if err = checkVBoxManageVersion(strings.TrimSpace(version)); err != nil {
return err
}
if !d.NoVTXCheck ... | go | {
"resource": ""
} |
q168237 | validateNoIPCollisions | validation | func validateNoIPCollisions(hif HostInterfaces, hostOnlyNet *net.IPNet, currHostOnlyNets map[string]*hostOnlyNetwork) error {
hostOnlyByCIDR := map[string]*hostOnlyNetwork{}
//listHostOnlyAdapters returns a map w/ virtualbox net names as key. Rekey to CIDRs
for _, n := range currHostOnlyNets {
ipnet := net.IPNet{... | go | {
"resource": ""
} |
q168238 | getAvailableTCPPort | validation | func getAvailableTCPPort(port int) (int, error) {
for i := 0; i <= 10; i++ {
ln, err := net.Listen("tcp4", fmt.Sprintf("127.0.0.1:%d", port))
if err != nil {
return 0, err
}
defer ln.Close()
addr := ln.Addr().String()
addrParts := strings.SplitN(addr, ":", 2)
p, err := strconv.Atoi(addrParts[1])
if ... | go | {
"resource": ""
} |
q168239 | setPortForwarding | validation | func setPortForwarding(d *Driver, interfaceNum int, mapName, protocol string, guestPort, desiredHostPort int) (int, error) {
actualHostPort, err := getAvailableTCPPort(desiredHostPort)
if err != nil {
return -1, err
}
if desiredHostPort != actualHostPort && desiredHostPort != 0 {
log.Debugf("NAT forwarding host... | go | {
"resource": ""
} |
q168240 | getRandomIPinSubnet | validation | func getRandomIPinSubnet(d *Driver, baseIP net.IP) (net.IP, error) {
var dhcpAddr net.IP
nAddr := baseIP.To4()
// select pseudo-random DHCP addr; make sure not to clash with the host
// only try 5 times and bail if no random received
for i := 0; i < 5; i++ {
n := d.randomInter.RandomInt(24) + 1
if byte(n) != ... | go | {
"resource": ""
} |
q168241 | Detect | validation | func Detect() (string, error) {
shell := os.Getenv("SHELL")
if shell == "" {
fmt.Printf("The default lines below are for a sh/bash shell, you can specify the shell you're using, with the --shell flag.\n\n")
return "", ErrUnknownShell
}
return filepath.Base(shell), nil
} | go | {
"resource": ""
} |
q168242 | vaultRenewDuration | validation | func vaultRenewDuration(s *Secret) time.Duration {
// Handle whether this is an auth or a regular secret.
base := s.LeaseDuration
if s.Auth != nil && s.Auth.LeaseDuration > 0 {
base = s.Auth.LeaseDuration
}
// Ensure we have a lease duration, since sometimes this can be zero.
if base <= 0 {
base = int(VaultD... | go | {
"resource": ""
} |
q168243 | printVaultWarnings | validation | func printVaultWarnings(d Dependency, warnings []string) {
for _, w := range warnings {
log.Printf("[WARN] %s: %s", d, w)
}
} | go | {
"resource": ""
} |
q168244 | vaultSecretRenewable | validation | func vaultSecretRenewable(s *Secret) bool {
if s.Auth != nil {
return s.Auth.Renewable
}
return s.Renewable
} | go | {
"resource": ""
} |
q168245 | transformSecret | validation | func transformSecret(theirs *api.Secret) *Secret {
var ours Secret
updateSecret(&ours, theirs)
return &ours
} | go | {
"resource": ""
} |
q168246 | updateSecret | validation | func updateSecret(ours *Secret, theirs *api.Secret) {
if theirs.RequestID != "" {
ours.RequestID = theirs.RequestID
}
if theirs.LeaseID != "" {
ours.LeaseID = theirs.LeaseID
}
if theirs.LeaseDuration != 0 {
ours.LeaseDuration = theirs.LeaseDuration
}
if theirs.Renewable {
ours.Renewable = theirs.Renew... | go | {
"resource": ""
} |
q168247 | Display | validation | func (c *TemplateConfig) Display() string {
if c == nil {
return ""
}
source := c.Source
if StringPresent(c.Contents) {
source = String("(dynamic)")
}
return fmt.Sprintf("%q => %q",
StringVal(source),
StringVal(c.Destination),
)
} | go | {
"resource": ""
} |
q168248 | NewVaultWriteQuery | validation | func NewVaultWriteQuery(s string, d map[string]interface{}) (*VaultWriteQuery, error) {
s = strings.TrimSpace(s)
s = strings.Trim(s, "/")
if s == "" {
return nil, fmt.Errorf("vault.write: invalid format: %q", s)
}
return &VaultWriteQuery{
stopCh: make(chan struct{}, 1),
path: s,
data: d,
dataH... | go | {
"resource": ""
} |
q168249 | sha1Map | validation | func sha1Map(m map[string]interface{}) string {
keys := make([]string, 0, len(m))
for k, _ := range m {
keys = append(keys, k)
}
sort.Strings(keys)
h := sha1.New()
for _, k := range keys {
io.WriteString(h, fmt.Sprintf("%s=%q", k, m[k]))
}
return fmt.Sprintf("%.4x", h.Sum(nil))
} | go | {
"resource": ""
} |
q168250 | NewView | validation | func NewView(i *NewViewInput) (*View, error) {
return &View{
dependency: i.Dependency,
clients: i.Clients,
maxStale: i.MaxStale,
once: i.Once,
retryFunc: i.RetryFunc,
stopCh: make(chan struct{}, 1),
vaultGrace: i.VaultGrace,
}, nil
} | go | {
"resource": ""
} |
q168251 | Data | validation | func (v *View) Data() interface{} {
v.dataLock.RLock()
defer v.dataLock.RUnlock()
return v.data
} | go | {
"resource": ""
} |
q168252 | DataAndLastIndex | validation | func (v *View) DataAndLastIndex() (interface{}, uint64) {
v.dataLock.RLock()
defer v.dataLock.RUnlock()
return v.data, v.lastIndex
} | go | {
"resource": ""
} |
q168253 | poll | validation | func (v *View) poll(viewCh chan<- *View, errCh chan<- error) {
var retries int
for {
doneCh := make(chan struct{}, 1)
successCh := make(chan struct{}, 1)
fetchErrCh := make(chan error, 1)
go v.fetch(doneCh, successCh, fetchErrCh)
WAIT:
select {
case <-doneCh:
// Reset the retry to avoid exponentiall... | go | {
"resource": ""
} |
q168254 | fetch | validation | func (v *View) fetch(doneCh, successCh chan<- struct{}, errCh chan<- error) {
log.Printf("[TRACE] (view) %s starting fetch", v.dependency)
var allowStale bool
if v.maxStale != 0 {
allowStale = true
}
for {
// If the view was stopped, short-circuit this loop. This prevents a bug
// where a view can get "los... | go | {
"resource": ""
} |
q168255 | NewCatalogNodeQuery | validation | func NewCatalogNodeQuery(s string) (*CatalogNodeQuery, error) {
if s != "" && !CatalogNodeQueryRe.MatchString(s) {
return nil, fmt.Errorf("catalog.node: invalid format: %q", s)
}
m := regexpMatch(CatalogNodeQueryRe, s)
return &CatalogNodeQuery{
dc: m["dc"],
name: m["name"],
stopCh: make(chan struct{}... | go | {
"resource": ""
} |
q168256 | Fetch | validation | func (d *CatalogNodeQuery) Fetch(clients *ClientSet, opts *QueryOptions) (interface{}, *ResponseMetadata, error) {
select {
case <-d.stopCh:
return nil, nil, ErrStopped
default:
}
opts = opts.Merge(&QueryOptions{
Datacenter: d.dc,
})
// Grab the name
name := d.name
if name == "" {
log.Printf("[TRACE] ... | go | {
"resource": ""
} |
q168257 | String | validation | func (c *AuthConfig) String() string {
if !BoolVal(c.Enabled) {
return ""
}
if c.Password != nil {
return fmt.Sprintf("%s:%s", StringVal(c.Username), StringVal(c.Password))
}
return StringVal(c.Username)
} | go | {
"resource": ""
} |
q168258 | NewVaultListQuery | validation | func NewVaultListQuery(s string) (*VaultListQuery, error) {
s = strings.TrimSpace(s)
s = strings.Trim(s, "/")
if s == "" {
return nil, fmt.Errorf("vault.list: invalid format: %q", s)
}
return &VaultListQuery{
stopCh: make(chan struct{}, 1),
path: s,
}, nil
} | go | {
"resource": ""
} |
q168259 | Remember | validation | func (b *Brain) Remember(d dep.Dependency, data interface{}) {
b.Lock()
defer b.Unlock()
b.data[d.String()] = data
b.receivedData[d.String()] = struct{}{}
} | go | {
"resource": ""
} |
q168260 | Recall | validation | func (b *Brain) Recall(d dep.Dependency) (interface{}, bool) {
b.RLock()
defer b.RUnlock()
// If we have not received data for this dependency, return now.
if _, ok := b.receivedData[d.String()]; !ok {
return nil, false
}
return b.data[d.String()], true
} | go | {
"resource": ""
} |
q168261 | ForceSet | validation | func (b *Brain) ForceSet(hashCode string, data interface{}) {
b.Lock()
defer b.Unlock()
b.data[hashCode] = data
b.receivedData[hashCode] = struct{}{}
} | go | {
"resource": ""
} |
q168262 | Forget | validation | func (b *Brain) Forget(d dep.Dependency) {
b.Lock()
defer b.Unlock()
delete(b.data, d.String())
delete(b.receivedData, d.String())
} | go | {
"resource": ""
} |
q168263 | NewCatalogDatacentersQuery | validation | func NewCatalogDatacentersQuery(ignoreFailing bool) (*CatalogDatacentersQuery, error) {
return &CatalogDatacentersQuery{
ignoreFailing: ignoreFailing,
stopCh: make(chan struct{}, 1),
}, nil
} | go | {
"resource": ""
} |
q168264 | Fetch | validation | func (d *CatalogDatacentersQuery) Fetch(clients *ClientSet, opts *QueryOptions) (interface{}, *ResponseMetadata, error) {
opts = opts.Merge(&QueryOptions{})
log.Printf("[TRACE] %s: GET %s", d, &url.URL{
Path: "/v1/catalog/datacenters",
RawQuery: opts.String(),
})
// This is pretty ghetto, but the datacent... | go | {
"resource": ""
} |
q168265 | NewCatalogNodesQuery | validation | func NewCatalogNodesQuery(s string) (*CatalogNodesQuery, error) {
if !CatalogNodesQueryRe.MatchString(s) {
return nil, fmt.Errorf("catalog.nodes: invalid format: %q", s)
}
m := regexpMatch(CatalogNodesQueryRe, s)
return &CatalogNodesQuery{
dc: m["dc"],
near: m["near"],
stopCh: make(chan struct{}, 1),... | go | {
"resource": ""
} |
q168266 | Fetch | validation | func (d *CatalogNodesQuery) Fetch(clients *ClientSet, opts *QueryOptions) (interface{}, *ResponseMetadata, error) {
select {
case <-d.stopCh:
return nil, nil, ErrStopped
default:
}
opts = opts.Merge(&QueryOptions{
Datacenter: d.dc,
Near: d.near,
})
log.Printf("[TRACE] %s: GET %s", d, &url.URL{
Pa... | go | {
"resource": ""
} |
q168267 | Parse | validation | func Parse(s string) (os.Signal, error) {
sig, ok := SignalLookup[strings.ToUpper(s)]
if !ok {
return nil, fmt.Errorf("invalid signal %q - valid signals are %q",
s, ValidSignals)
}
return sig, nil
} | go | {
"resource": ""
} |
q168268 | DefaultVaultConfig | validation | func DefaultVaultConfig() *VaultConfig {
v := &VaultConfig{
Retry: DefaultRetryConfig(),
SSL: DefaultSSLConfig(),
Transport: DefaultTransportConfig(),
}
// Force SSL when communicating with Vault.
v.SSL.Enabled = Bool(true)
return v
} | go | {
"resource": ""
} |
q168269 | NewTemplate | validation | func NewTemplate(i *NewTemplateInput) (*Template, error) {
if i == nil {
i = &NewTemplateInput{}
}
// Validate that we are either given the path or the explicit contents
if i.Source != "" && i.Contents != "" {
return nil, ErrTemplateContentsAndSource
} else if i.Source == "" && i.Contents == "" {
return nil... | go | {
"resource": ""
} |
q168270 | Execute | validation | func (t *Template) Execute(i *ExecuteInput) (*ExecuteResult, error) {
if i == nil {
i = &ExecuteInput{}
}
var used, missing dep.Set
tmpl := template.New("")
tmpl.Delims(t.leftDelim, t.rightDelim)
tmpl.Funcs(funcMap(&funcMapInput{
t: tmpl,
brain: i.Brain,
env: i.Env,
used: &used,
missi... | go | {
"resource": ""
} |
q168271 | funcMap | validation | func funcMap(i *funcMapInput) template.FuncMap {
var scratch Scratch
return template.FuncMap{
// API functions
"datacenters": datacentersFunc(i.brain, i.used, i.missing),
"file": fileFunc(i.brain, i.used, i.missing),
"key": keyFunc(i.brain, i.used, i.missing),
"keyExists": keyExistsFun... | go | {
"resource": ""
} |
q168272 | StringToFileModeFunc | validation | func StringToFileModeFunc() mapstructure.DecodeHookFunc {
return func(
f reflect.Type,
t reflect.Type,
data interface{}) (interface{}, error) {
if f.Kind() != reflect.String {
return data, nil
}
if t != reflect.TypeOf(os.FileMode(0)) {
return data, nil
}
// Convert it by parsing
v, err := strc... | go | {
"resource": ""
} |
q168273 | StringToWaitDurationHookFunc | validation | func StringToWaitDurationHookFunc() mapstructure.DecodeHookFunc {
return func(
f reflect.Type,
t reflect.Type,
data interface{}) (interface{}, error) {
if f.Kind() != reflect.String {
return data, nil
}
if t != reflect.TypeOf(WaitConfig{}) {
return data, nil
}
// Convert it by parsing
return P... | go | {
"resource": ""
} |
q168274 | ConsulStringToStructFunc | validation | func ConsulStringToStructFunc() mapstructure.DecodeHookFunc {
return func(
f reflect.Type,
t reflect.Type,
data interface{}) (interface{}, error) {
if t == reflect.TypeOf(ConsulConfig{}) && f.Kind() == reflect.String {
log.Println("[WARN] consul now accepts a stanza instead of a string. " +
"Update your... | go | {
"resource": ""
} |
q168275 | Key | validation | func (s *Scratch) Key(k string) bool {
s.RLock()
defer s.RUnlock()
_, ok := s.values[k]
return ok
} | go | {
"resource": ""
} |
q168276 | Get | validation | func (s *Scratch) Get(k string) interface{} {
s.RLock()
defer s.RUnlock()
return s.values[k]
} | go | {
"resource": ""
} |
q168277 | Set | validation | func (s *Scratch) Set(k string, v interface{}) string {
s.init()
s.Lock()
defer s.Unlock()
s.values[k] = v
return ""
} | go | {
"resource": ""
} |
q168278 | SetX | validation | func (s *Scratch) SetX(k string, v interface{}) string {
s.init()
s.Lock()
defer s.Unlock()
if _, ok := s.values[k]; !ok {
s.values[k] = v
}
return ""
} | go | {
"resource": ""
} |
q168279 | MapSet | validation | func (s *Scratch) MapSet(k, mk string, v interface{}) (string, error) {
s.init()
s.Lock()
defer s.Unlock()
return s.mapSet(k, mk, v, true)
} | go | {
"resource": ""
} |
q168280 | MapSetX | validation | func (s *Scratch) MapSetX(k, mk string, v interface{}) (string, error) {
s.init()
s.Lock()
defer s.Unlock()
return s.mapSet(k, mk, v, false)
} | go | {
"resource": ""
} |
q168281 | mapSet | validation | func (s *Scratch) mapSet(k, mk string, v interface{}, o bool) (string, error) {
if _, ok := s.values[k]; !ok {
s.values[k] = make(map[string]interface{})
}
typed, ok := s.values[k].(map[string]interface{})
if !ok {
return "", fmt.Errorf("%q is not a map", k)
}
if _, ok := typed[mk]; o || !ok {
typed[mk] =... | go | {
"resource": ""
} |
q168282 | MapValues | validation | func (s *Scratch) MapValues(k string) ([]interface{}, error) {
s.init()
s.Lock()
defer s.Unlock()
if s.values == nil {
return nil, nil
}
typed, ok := s.values[k].(map[string]interface{})
if !ok {
return nil, nil
}
keys := make([]string, 0, len(typed))
for k := range typed {
keys = append(keys, k)
}
... | go | {
"resource": ""
} |
q168283 | init | validation | func (s *Scratch) init() {
if s.values == nil {
s.values = make(map[string]interface{})
}
} | go | {
"resource": ""
} |
q168284 | Render | validation | func Render(i *RenderInput) (*RenderResult, error) {
existing, err := ioutil.ReadFile(i.Path)
if err != nil && !os.IsNotExist(err) {
return nil, errors.Wrap(err, "failed reading file")
}
if bytes.Equal(existing, i.Contents) {
return &RenderResult{
DidRender: false,
WouldRender: true,
Contents: ex... | go | {
"resource": ""
} |
q168285 | copyFile | validation | func copyFile(src, dst string) error {
s, err := os.Open(src)
if err != nil {
return err
}
defer s.Close()
stat, err := s.Stat()
if err != nil {
return err
}
d, err := os.OpenFile(dst, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, stat.Mode())
if err != nil {
return err
}
if _, err := io.Copy(d, s); err != nil... | go | {
"resource": ""
} |
q168286 | Copy | validation | func (c *Config) Copy() *Config {
var o Config
o.Consul = c.Consul
if c.Consul != nil {
o.Consul = c.Consul.Copy()
}
if c.Dedup != nil {
o.Dedup = c.Dedup.Copy()
}
if c.Exec != nil {
o.Exec = c.Exec.Copy()
}
o.KillSignal = c.KillSignal
o.LogLevel = c.LogLevel
o.MaxStale = c.MaxStale
o.PidFile ... | go | {
"resource": ""
} |
q168287 | Merge | validation | func (c *Config) Merge(o *Config) *Config {
if c == nil {
if o == nil {
return nil
}
return o.Copy()
}
if o == nil {
return c.Copy()
}
r := c.Copy()
if o.Consul != nil {
r.Consul = r.Consul.Merge(o.Consul)
}
if o.Dedup != nil {
r.Dedup = r.Dedup.Merge(o.Dedup)
}
if o.Exec != nil {
r.Exec... | go | {
"resource": ""
} |
q168288 | Parse | validation | func Parse(s string) (*Config, error) {
var shadow interface{}
if err := hcl.Decode(&shadow, s); err != nil {
return nil, errors.Wrap(err, "error decoding config")
}
// Convert to a map and flatten the keys we want to flatten
parsed, ok := shadow.(map[string]interface{})
if !ok {
return nil, errors.New("erro... | go | {
"resource": ""
} |
q168289 | Must | validation | func Must(s string) *Config {
c, err := Parse(s)
if err != nil {
log.Fatal(err)
}
return c
} | go | {
"resource": ""
} |
q168290 | FromFile | validation | func FromFile(path string) (*Config, error) {
c, err := ioutil.ReadFile(path)
if err != nil {
return nil, errors.Wrap(err, "from file: "+path)
}
config, err := Parse(string(c))
if err != nil {
return nil, errors.Wrap(err, "from file: "+path)
}
return config, nil
} | go | {
"resource": ""
} |
q168291 | FromPath | validation | func FromPath(path string) (*Config, error) {
// Ensure the given filepath exists
if _, err := os.Stat(path); os.IsNotExist(err) {
return nil, errors.Wrap(err, "missing file/folder: "+path)
}
// Check if a file was given or a path to a directory
stat, err := os.Stat(path)
if err != nil {
return nil, errors.W... | go | {
"resource": ""
} |
q168292 | DefaultConfig | validation | func DefaultConfig() *Config {
return &Config{
Consul: DefaultConsulConfig(),
Dedup: DefaultDedupConfig(),
Exec: DefaultExecConfig(),
Syslog: DefaultSyslogConfig(),
Templates: DefaultTemplateConfigs(),
Vault: DefaultVaultConfig(),
Wait: DefaultWaitConfig(),
}
} | go | {
"resource": ""
} |
q168293 | NewWatcher | validation | func NewWatcher(i *NewWatcherInput) (*Watcher, error) {
w := &Watcher{
clients: i.Clients,
depViewMap: make(map[string]*View),
dataCh: make(chan *View, dataBufferSize),
errCh: make(chan error),
maxStale: i.MaxStale,
once: i.Once,
retryFuncConsul: i... | go | {
"resource": ""
} |
q168294 | Watching | validation | func (w *Watcher) Watching(d dep.Dependency) bool {
w.Lock()
defer w.Unlock()
_, ok := w.depViewMap[d.String()]
return ok
} | go | {
"resource": ""
} |
q168295 | ForceWatching | validation | func (w *Watcher) ForceWatching(d dep.Dependency, enabled bool) {
w.Lock()
defer w.Unlock()
if enabled {
w.depViewMap[d.String()] = nil
} else {
delete(w.depViewMap, d.String())
}
} | go | {
"resource": ""
} |
q168296 | Remove | validation | func (w *Watcher) Remove(d dep.Dependency) bool {
w.Lock()
defer w.Unlock()
log.Printf("[DEBUG] (watcher) removing %s", d)
if view, ok := w.depViewMap[d.String()]; ok {
log.Printf("[TRACE] (watcher) actually removing %s", d)
view.stop()
delete(w.depViewMap, d.String())
return true
}
log.Printf("[TRACE]... | go | {
"resource": ""
} |
q168297 | Size | validation | func (w *Watcher) Size() int {
w.Lock()
defer w.Unlock()
return len(w.depViewMap)
} | go | {
"resource": ""
} |
q168298 | Stop | validation | func (w *Watcher) Stop() {
w.Lock()
defer w.Unlock()
log.Printf("[DEBUG] (watcher) stopping all views")
for _, view := range w.depViewMap {
if view == nil {
continue
}
log.Printf("[TRACE] (watcher) stopping %s", view.Dependency())
view.stop()
}
// Reset the map to have no views
w.depViewMap = make(... | go | {
"resource": ""
} |
q168299 | Add | validation | func (s *Set) Add(d Dependency) bool {
s.init()
s.Lock()
defer s.Unlock()
if _, ok := s.set[d.String()]; !ok {
s.list = append(s.list, d.String())
s.set[d.String()] = d
return true
}
return false
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.