_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q173100 | RecordCountForValue | validation | func (m *CirconusMetrics) RecordCountForValue(metric string, val float64, n int64) {
hist := m.NewHistogram(metric)
m.hm.Lock()
hist.rw.Lock()
hist.hist.RecordValues(val, n)
hist.rw.Unlock()
m.hm.Unlock()
} | go | {
"resource": ""
} |
q173101 | SetHistogramValue | validation | func (m *CirconusMetrics) SetHistogramValue(metric string, val float64) {
hist := m.NewHistogram(metric)
m.hm.Lock()
hist.rw.Lock()
hist.hist.RecordValue(val)
hist.rw.Unlock()
m.hm.Unlock()
} | go | {
"resource": ""
} |
q173102 | RemoveHistogram | validation | func (m *CirconusMetrics) RemoveHistogram(metric string) {
m.hm.Lock()
delete(m.histograms, metric)
m.hm.Unlock()
} | go | {
"resource": ""
} |
q173103 | NewHistogram | validation | func (m *CirconusMetrics) NewHistogram(metric string) *Histogram {
m.hm.Lock()
defer m.hm.Unlock()
if hist, ok := m.histograms[metric]; ok {
return hist
}
hist := &Histogram{
name: metric,
hist: circonusllhist.New(),
}
m.histograms[metric] = hist
return hist
} | go | {
"resource": ""
} |
q173104 | RecordValue | validation | func (h *Histogram) RecordValue(v float64) {
h.rw.Lock()
h.hist.RecordValue(v)
h.rw.Unlock()
} | go | {
"resource": ""
} |
q173105 | checkBundleSearch | validation | func (cm *CheckManager) checkBundleSearch(criteria string, filter map[string][]string) (*api.CheckBundle, error) {
search := api.SearchQueryType(criteria)
checkBundles, err := cm.apih.SearchCheckBundles(&search, &filter)
if err != nil {
return nil, err
}
if len(*checkBundles) == 0 {
return nil, nil // trigger... | go | {
"resource": ""
} |
q173106 | createNewCheck | validation | func (cm *CheckManager) createNewCheck() (*api.CheckBundle, *api.Broker, error) {
checkSecret := string(cm.checkSecret)
if checkSecret == "" {
secret, err := cm.makeSecret()
if err != nil {
secret = "myS3cr3t"
}
checkSecret = secret
}
broker, err := cm.getBroker()
if err != nil {
return nil, nil, err... | go | {
"resource": ""
} |
q173107 | makeSecret | validation | func (cm *CheckManager) makeSecret() (string, error) {
hash := sha256.New()
x := make([]byte, 2048)
if _, err := rand.Read(x); err != nil {
return "", err
}
hash.Write(x)
return hex.EncodeToString(hash.Sum(nil))[0:16], nil
} | go | {
"resource": ""
} |
q173108 | fetchCheckBySubmissionURL | validation | func (cm *CheckManager) fetchCheckBySubmissionURL(submissionURL api.URLType) (*api.Check, error) {
if string(submissionURL) == "" {
return nil, errors.New("[ERROR] Invalid submission URL (blank)")
}
u, err := url.Parse(string(submissionURL))
if err != nil {
return nil, err
}
// valid trap url: scheme://host... | go | {
"resource": ""
} |
q173109 | Initialize | validation | func (cm *CheckManager) Initialize() {
// if not managing the check, quicker initialization
if !cm.enabled {
err := cm.initializeTrapURL()
if err == nil {
cm.initializedmu.Lock()
cm.initialized = true
cm.initializedmu.Unlock()
} else {
cm.Log.Printf("[WARN] error initializing trap %s", err.Error())... | go | {
"resource": ""
} |
q173110 | IsReady | validation | func (cm *CheckManager) IsReady() bool {
cm.initializedmu.RLock()
defer cm.initializedmu.RUnlock()
return cm.initialized
} | go | {
"resource": ""
} |
q173111 | GetSubmissionURL | validation | func (cm *CheckManager) GetSubmissionURL() (*Trap, error) {
if cm.trapURL == "" {
return nil, errors.Errorf("get submission url - submission url unavailable")
}
trap := &Trap{}
u, err := url.Parse(string(cm.trapURL))
if err != nil {
return nil, errors.Wrap(err, "get submission url")
}
trap.URL = u
if u.S... | go | {
"resource": ""
} |
q173112 | ResetTrap | validation | func (cm *CheckManager) ResetTrap() error {
if cm.trapURL == "" {
return nil
}
cm.trapURL = ""
cm.certPool = nil // force re-fetching CA cert (if custom TLS config not supplied)
return cm.initializeTrapURL()
} | go | {
"resource": ""
} |
q173113 | RefreshTrap | validation | func (cm *CheckManager) RefreshTrap() error {
if cm.trapURL == "" {
return nil
}
if time.Since(cm.trapLastUpdate) >= cm.trapMaxURLAge {
return cm.ResetTrap()
}
return nil
} | go | {
"resource": ""
} |
q173114 | FetchRuleSetGroup | validation | func (a *API) FetchRuleSetGroup(cid CIDType) (*RuleSetGroup, error) {
if cid == nil || *cid == "" {
return nil, fmt.Errorf("Invalid rule set group CID [none]")
}
groupCID := string(*cid)
matched, err := regexp.MatchString(config.RuleSetGroupCIDRegex, groupCID)
if err != nil {
return nil, err
}
if !matched ... | go | {
"resource": ""
} |
q173115 | FetchRuleSetGroups | validation | func (a *API) FetchRuleSetGroups() (*[]RuleSetGroup, error) {
result, err := a.Get(config.RuleSetGroupPrefix)
if err != nil {
return nil, err
}
var rulesetGroups []RuleSetGroup
if err := json.Unmarshal(result, &rulesetGroups); err != nil {
return nil, err
}
return &rulesetGroups, nil
} | go | {
"resource": ""
} |
q173116 | UpdateRuleSetGroup | validation | func (a *API) UpdateRuleSetGroup(cfg *RuleSetGroup) (*RuleSetGroup, error) {
if cfg == nil {
return nil, fmt.Errorf("Invalid rule set group config [nil]")
}
groupCID := string(cfg.CID)
matched, err := regexp.MatchString(config.RuleSetGroupCIDRegex, groupCID)
if err != nil {
return nil, err
}
if !matched {
... | go | {
"resource": ""
} |
q173117 | CreateRuleSetGroup | validation | func (a *API) CreateRuleSetGroup(cfg *RuleSetGroup) (*RuleSetGroup, error) {
if cfg == nil {
return nil, fmt.Errorf("Invalid rule set group config [nil]")
}
jsonCfg, err := json.Marshal(cfg)
if err != nil {
return nil, err
}
if a.Debug {
a.Log.Printf("[DEBUG] create rule set group, sending JSON: %s", stri... | go | {
"resource": ""
} |
q173118 | DeleteRuleSetGroup | validation | func (a *API) DeleteRuleSetGroup(cfg *RuleSetGroup) (bool, error) {
if cfg == nil {
return false, fmt.Errorf("Invalid rule set group config [nil]")
}
return a.DeleteRuleSetGroupByCID(CIDType(&cfg.CID))
} | go | {
"resource": ""
} |
q173119 | DeleteRuleSetGroupByCID | validation | func (a *API) DeleteRuleSetGroupByCID(cid CIDType) (bool, error) {
if cid == nil || *cid == "" {
return false, fmt.Errorf("Invalid rule set group CID [none]")
}
groupCID := string(*cid)
matched, err := regexp.MatchString(config.RuleSetGroupCIDRegex, groupCID)
if err != nil {
return false, err
}
if !matched... | go | {
"resource": ""
} |
q173120 | FetchDashboard | validation | func (a *API) FetchDashboard(cid CIDType) (*Dashboard, error) {
if cid == nil || *cid == "" {
return nil, fmt.Errorf("Invalid dashboard CID [none]")
}
dashboardCID := string(*cid)
matched, err := regexp.MatchString(config.DashboardCIDRegex, dashboardCID)
if err != nil {
return nil, err
}
if !matched {
re... | go | {
"resource": ""
} |
q173121 | FetchDashboards | validation | func (a *API) FetchDashboards() (*[]Dashboard, error) {
result, err := a.Get(config.DashboardPrefix)
if err != nil {
return nil, err
}
var dashboards []Dashboard
if err := json.Unmarshal(result, &dashboards); err != nil {
return nil, err
}
return &dashboards, nil
} | go | {
"resource": ""
} |
q173122 | UpdateDashboard | validation | func (a *API) UpdateDashboard(cfg *Dashboard) (*Dashboard, error) {
if cfg == nil {
return nil, fmt.Errorf("Invalid dashboard config [nil]")
}
dashboardCID := string(cfg.CID)
matched, err := regexp.MatchString(config.DashboardCIDRegex, dashboardCID)
if err != nil {
return nil, err
}
if !matched {
return ... | go | {
"resource": ""
} |
q173123 | CreateDashboard | validation | func (a *API) CreateDashboard(cfg *Dashboard) (*Dashboard, error) {
if cfg == nil {
return nil, fmt.Errorf("Invalid dashboard config [nil]")
}
jsonCfg, err := json.Marshal(cfg)
if err != nil {
return nil, err
}
if a.Debug {
a.Log.Printf("[DEBUG] create dashboard, sending JSON: %s", string(jsonCfg))
}
r... | go | {
"resource": ""
} |
q173124 | DeleteDashboard | validation | func (a *API) DeleteDashboard(cfg *Dashboard) (bool, error) {
if cfg == nil {
return false, fmt.Errorf("Invalid dashboard config [nil]")
}
return a.DeleteDashboardByCID(CIDType(&cfg.CID))
} | go | {
"resource": ""
} |
q173125 | DeleteDashboardByCID | validation | func (a *API) DeleteDashboardByCID(cid CIDType) (bool, error) {
if cid == nil || *cid == "" {
return false, fmt.Errorf("Invalid dashboard CID [none]")
}
dashboardCID := string(*cid)
matched, err := regexp.MatchString(config.DashboardCIDRegex, dashboardCID)
if err != nil {
return false, err
}
if !matched {
... | go | {
"resource": ""
} |
q173126 | SetText | validation | func (m *CirconusMetrics) SetText(metric string, val string) {
m.SetTextValue(metric, val)
} | go | {
"resource": ""
} |
q173127 | SetTextValue | validation | func (m *CirconusMetrics) SetTextValue(metric string, val string) {
m.tm.Lock()
defer m.tm.Unlock()
m.text[metric] = val
} | go | {
"resource": ""
} |
q173128 | RemoveText | validation | func (m *CirconusMetrics) RemoveText(metric string) {
m.tm.Lock()
defer m.tm.Unlock()
delete(m.text, metric)
} | go | {
"resource": ""
} |
q173129 | RemoveTextFunc | validation | func (m *CirconusMetrics) RemoveTextFunc(metric string) {
m.tfm.Lock()
defer m.tfm.Unlock()
delete(m.textFuncs, metric)
} | go | {
"resource": ""
} |
q173130 | FetchAlert | validation | func (a *API) FetchAlert(cid CIDType) (*Alert, error) {
if cid == nil || *cid == "" {
return nil, fmt.Errorf("Invalid alert CID [none]")
}
alertCID := string(*cid)
matched, err := regexp.MatchString(config.AlertCIDRegex, alertCID)
if err != nil {
return nil, err
}
if !matched {
return nil, fmt.Errorf("In... | go | {
"resource": ""
} |
q173131 | FetchAlerts | validation | func (a *API) FetchAlerts() (*[]Alert, error) {
result, err := a.Get(config.AlertPrefix)
if err != nil {
return nil, err
}
var alerts []Alert
if err := json.Unmarshal(result, &alerts); err != nil {
return nil, err
}
return &alerts, nil
} | go | {
"resource": ""
} |
q173132 | FetchRuleSet | validation | func (a *API) FetchRuleSet(cid CIDType) (*RuleSet, error) {
if cid == nil || *cid == "" {
return nil, fmt.Errorf("Invalid rule set CID [none]")
}
rulesetCID := string(*cid)
matched, err := regexp.MatchString(config.RuleSetCIDRegex, rulesetCID)
if err != nil {
return nil, err
}
if !matched {
return nil, f... | go | {
"resource": ""
} |
q173133 | FetchRuleSets | validation | func (a *API) FetchRuleSets() (*[]RuleSet, error) {
result, err := a.Get(config.RuleSetPrefix)
if err != nil {
return nil, err
}
var rulesets []RuleSet
if err := json.Unmarshal(result, &rulesets); err != nil {
return nil, err
}
return &rulesets, nil
} | go | {
"resource": ""
} |
q173134 | UpdateRuleSet | validation | func (a *API) UpdateRuleSet(cfg *RuleSet) (*RuleSet, error) {
if cfg == nil {
return nil, fmt.Errorf("Invalid rule set config [nil]")
}
rulesetCID := string(cfg.CID)
matched, err := regexp.MatchString(config.RuleSetCIDRegex, rulesetCID)
if err != nil {
return nil, err
}
if !matched {
return nil, fmt.Erro... | go | {
"resource": ""
} |
q173135 | CreateRuleSet | validation | func (a *API) CreateRuleSet(cfg *RuleSet) (*RuleSet, error) {
if cfg == nil {
return nil, fmt.Errorf("Invalid rule set config [nil]")
}
jsonCfg, err := json.Marshal(cfg)
if err != nil {
return nil, err
}
if a.Debug {
a.Log.Printf("[DEBUG] create rule set, sending JSON: %s", string(jsonCfg))
}
resp, err... | go | {
"resource": ""
} |
q173136 | DeleteRuleSet | validation | func (a *API) DeleteRuleSet(cfg *RuleSet) (bool, error) {
if cfg == nil {
return false, fmt.Errorf("Invalid rule set config [nil]")
}
return a.DeleteRuleSetByCID(CIDType(&cfg.CID))
} | go | {
"resource": ""
} |
q173137 | DeleteRuleSetByCID | validation | func (a *API) DeleteRuleSetByCID(cid CIDType) (bool, error) {
if cid == nil || *cid == "" {
return false, fmt.Errorf("Invalid rule set CID [none]")
}
rulesetCID := string(*cid)
matched, err := regexp.MatchString(config.RuleSetCIDRegex, rulesetCID)
if err != nil {
return false, err
}
if !matched {
return ... | go | {
"resource": ""
} |
q173138 | IncrementByValue | validation | func (m *CirconusMetrics) IncrementByValue(metric string, val uint64) {
m.Add(metric, val)
} | go | {
"resource": ""
} |
q173139 | Set | validation | func (m *CirconusMetrics) Set(metric string, val uint64) {
m.cm.Lock()
defer m.cm.Unlock()
m.counters[metric] = val
} | go | {
"resource": ""
} |
q173140 | RemoveCounter | validation | func (m *CirconusMetrics) RemoveCounter(metric string) {
m.cm.Lock()
defer m.cm.Unlock()
delete(m.counters, metric)
} | go | {
"resource": ""
} |
q173141 | RemoveCounterFunc | validation | func (m *CirconusMetrics) RemoveCounterFunc(metric string) {
m.cfm.Lock()
defer m.cfm.Unlock()
delete(m.counterFuncs, metric)
} | go | {
"resource": ""
} |
q173142 | PromOutput | validation | func (m *CirconusMetrics) PromOutput() (*bytes.Buffer, error) {
m.lastMetrics.metricsmu.Lock()
defer m.lastMetrics.metricsmu.Unlock()
if m.lastMetrics.metrics == nil {
return nil, errors.New("no metrics available")
}
var b bytes.Buffer
w := bufio.NewWriter(&b)
ts := m.lastMetrics.ts.UnixNano() / int64(time.... | go | {
"resource": ""
} |
q173143 | Flush | validation | func (m *CirconusMetrics) Flush() {
m.flushmu.Lock()
if m.flushing {
m.flushmu.Unlock()
return
}
m.flushing = true
m.flushmu.Unlock()
newMetrics, output := m.packageMetrics()
if len(output) > 0 {
m.submit(output, newMetrics)
} else {
if m.Debug {
m.Log.Println("[DEBUG] No metrics to send, skipping... | go | {
"resource": ""
} |
q173144 | FetchWorksheet | validation | func (a *API) FetchWorksheet(cid CIDType) (*Worksheet, error) {
if cid == nil || *cid == "" {
return nil, fmt.Errorf("Invalid worksheet CID [none]")
}
worksheetCID := string(*cid)
matched, err := regexp.MatchString(config.WorksheetCIDRegex, worksheetCID)
if err != nil {
return nil, err
}
if !matched {
re... | go | {
"resource": ""
} |
q173145 | FetchWorksheets | validation | func (a *API) FetchWorksheets() (*[]Worksheet, error) {
result, err := a.Get(config.WorksheetPrefix)
if err != nil {
return nil, err
}
var worksheets []Worksheet
if err := json.Unmarshal(result, &worksheets); err != nil {
return nil, err
}
return &worksheets, nil
} | go | {
"resource": ""
} |
q173146 | UpdateWorksheet | validation | func (a *API) UpdateWorksheet(cfg *Worksheet) (*Worksheet, error) {
if cfg == nil {
return nil, fmt.Errorf("Invalid worksheet config [nil]")
}
worksheetCID := string(cfg.CID)
matched, err := regexp.MatchString(config.WorksheetCIDRegex, worksheetCID)
if err != nil {
return nil, err
}
if !matched {
return ... | go | {
"resource": ""
} |
q173147 | CreateWorksheet | validation | func (a *API) CreateWorksheet(cfg *Worksheet) (*Worksheet, error) {
if cfg == nil {
return nil, fmt.Errorf("Invalid worksheet config [nil]")
}
jsonCfg, err := json.Marshal(cfg)
if err != nil {
return nil, err
}
if a.Debug {
a.Log.Printf("[DEBUG] create annotation, sending JSON: %s", string(jsonCfg))
}
... | go | {
"resource": ""
} |
q173148 | DeleteWorksheet | validation | func (a *API) DeleteWorksheet(cfg *Worksheet) (bool, error) {
if cfg == nil {
return false, fmt.Errorf("Invalid worksheet config [nil]")
}
return a.DeleteWorksheetByCID(CIDType(&cfg.CID))
} | go | {
"resource": ""
} |
q173149 | DeleteWorksheetByCID | validation | func (a *API) DeleteWorksheetByCID(cid CIDType) (bool, error) {
if cid == nil || *cid == "" {
return false, fmt.Errorf("Invalid worksheet CID [none]")
}
worksheetCID := string(*cid)
matched, err := regexp.MatchString(config.WorksheetCIDRegex, worksheetCID)
if err != nil {
return false, err
}
if !matched {
... | go | {
"resource": ""
} |
q173150 | FetchContactGroup | validation | func (a *API) FetchContactGroup(cid CIDType) (*ContactGroup, error) {
if cid == nil || *cid == "" {
return nil, fmt.Errorf("Invalid contact group CID [none]")
}
groupCID := string(*cid)
matched, err := regexp.MatchString(config.ContactGroupCIDRegex, groupCID)
if err != nil {
return nil, err
}
if !matched {... | go | {
"resource": ""
} |
q173151 | FetchContactGroups | validation | func (a *API) FetchContactGroups() (*[]ContactGroup, error) {
result, err := a.Get(config.ContactGroupPrefix)
if err != nil {
return nil, err
}
var groups []ContactGroup
if err := json.Unmarshal(result, &groups); err != nil {
return nil, err
}
return &groups, nil
} | go | {
"resource": ""
} |
q173152 | UpdateContactGroup | validation | func (a *API) UpdateContactGroup(cfg *ContactGroup) (*ContactGroup, error) {
if cfg == nil {
return nil, fmt.Errorf("Invalid contact group config [nil]")
}
groupCID := string(cfg.CID)
matched, err := regexp.MatchString(config.ContactGroupCIDRegex, groupCID)
if err != nil {
return nil, err
}
if !matched {
... | go | {
"resource": ""
} |
q173153 | CreateContactGroup | validation | func (a *API) CreateContactGroup(cfg *ContactGroup) (*ContactGroup, error) {
if cfg == nil {
return nil, fmt.Errorf("Invalid contact group config [nil]")
}
jsonCfg, err := json.Marshal(cfg)
if err != nil {
return nil, err
}
if a.Debug {
a.Log.Printf("[DEBUG] create contact group, sending JSON: %s", string... | go | {
"resource": ""
} |
q173154 | DeleteContactGroup | validation | func (a *API) DeleteContactGroup(cfg *ContactGroup) (bool, error) {
if cfg == nil {
return false, fmt.Errorf("Invalid contact group config [nil]")
}
return a.DeleteContactGroupByCID(CIDType(&cfg.CID))
} | go | {
"resource": ""
} |
q173155 | FetchBroker | validation | func (a *API) FetchBroker(cid CIDType) (*Broker, error) {
if cid == nil || *cid == "" {
return nil, fmt.Errorf("Invalid broker CID [none]")
}
brokerCID := string(*cid)
matched, err := regexp.MatchString(config.BrokerCIDRegex, brokerCID)
if err != nil {
return nil, err
}
if !matched {
return nil, fmt.Erro... | go | {
"resource": ""
} |
q173156 | FetchBrokers | validation | func (a *API) FetchBrokers() (*[]Broker, error) {
result, err := a.Get(config.BrokerPrefix)
if err != nil {
return nil, err
}
var response []Broker
if err := json.Unmarshal(result, &response); err != nil {
return nil, err
}
return &response, nil
} | go | {
"resource": ""
} |
q173157 | ActivateMetric | validation | func (cm *CheckManager) ActivateMetric(name string) bool {
cm.availableMetricsmu.Lock()
defer cm.availableMetricsmu.Unlock()
active, exists := cm.availableMetrics[name]
if !exists {
return true
}
if !active && cm.forceMetricActivation {
return true
}
return false
} | go | {
"resource": ""
} |
q173158 | AddMetricTags | validation | func (cm *CheckManager) AddMetricTags(metricName string, tags []string, appendTags bool) bool {
tagsUpdated := false
if appendTags && len(tags) == 0 {
return tagsUpdated
}
currentTags, exists := cm.metricTags[metricName]
if !exists {
foundMetric := false
if cm.checkBundle != nil {
for _, metric := rang... | go | {
"resource": ""
} |
q173159 | addNewMetrics | validation | func (cm *CheckManager) addNewMetrics(newMetrics map[string]*api.CheckBundleMetric) bool {
updatedCheckBundle := false
if cm.checkBundle == nil || len(newMetrics) == 0 {
return updatedCheckBundle
}
cm.cbmu.Lock()
defer cm.cbmu.Unlock()
numCurrMetrics := len(cm.checkBundle.Metrics)
numNewMetrics := len(newMe... | go | {
"resource": ""
} |
q173160 | inventoryMetrics | validation | func (cm *CheckManager) inventoryMetrics() {
availableMetrics := make(map[string]bool)
for _, metric := range cm.checkBundle.Metrics {
availableMetrics[metric.Name] = metric.Status == "active"
}
cm.availableMetricsmu.Lock()
cm.availableMetrics = availableMetrics
cm.availableMetricsmu.Unlock()
} | go | {
"resource": ""
} |
q173161 | countNewTags | validation | func countNewTags(currTags []string, newTags []string) int {
if len(newTags) == 0 {
return 0
}
if len(currTags) == 0 {
return len(newTags)
}
newTagCount := 0
for _, newTag := range newTags {
found := false
for _, currTag := range currTags {
if newTag == currTag {
found = true
break
}
}
... | go | {
"resource": ""
} |
q173162 | Pluralize | validation | func (rs *Ruleset) Pluralize(word string) string {
if len(word) == 0 {
return word
}
if rs.isUncountable(word) {
return word
}
for _, rule := range rs.plurals {
if rule.exact {
if word == rule.suffix {
return rule.replacement
}
} else {
if strings.HasSuffix(word, rule.suffix) {
return repl... | go | {
"resource": ""
} |
q173163 | Singularize | validation | func (rs *Ruleset) Singularize(word string) string {
if len(word) == 0 {
return word
}
if rs.isUncountable(word) {
return word
}
for _, rule := range rs.singulars {
if rule.exact {
if word == rule.suffix {
return rule.replacement
}
} else {
if strings.HasSuffix(word, rule.suffix) {
return ... | go | {
"resource": ""
} |
q173164 | Capitalize | validation | func (rs *Ruleset) Capitalize(word string) string {
return strings.ToUpper(word[:1]) + word[1:]
} | go | {
"resource": ""
} |
q173165 | Camelize | validation | func (rs *Ruleset) Camelize(word string) string {
words := splitAtCaseChangeWithTitlecase(word)
return strings.Join(words, "")
} | go | {
"resource": ""
} |
q173166 | getSuitableAlgFromCurve | validation | func getSuitableAlgFromCurve(curve elliptic.Curve) (jwt.Algorithm, error) {
curveBitSize := curve.Params().BitSize
// compute curve key len
keyLen := curveBitSize / 8
if curveBitSize%8 > 0 {
keyLen++
}
// determine alg
var alg jwt.Algorithm
switch 2 * keyLen {
case 64:
alg = jwt.ES256
case 96:
alg = j... | go | {
"resource": ""
} |
q173167 | getAlgFromKeyData | validation | func getAlgFromKeyData(pem pemutil.Store) (jwt.Algorithm, error) {
for _, v := range pem {
// loop over crypto primitives in pemstore, and do type assertion. if
// ecdsa.{PublicKey,PrivateKey} found, then use corresponding ESXXX as
// algo. if rsa, then use DefaultRSAAlgorithm. if []byte, then use
// DefaultHM... | go | {
"resource": ""
} |
q173168 | buildEncArgs | validation | func buildEncArgs(args []string) ([]byte, error) {
m := make(map[string]interface{})
// loop over args, splitting on '=', and attempt parsing of value
for _, arg := range args {
a := strings.SplitN(arg, "=", 2)
var val interface{}
// attempt to parse
if len(a) == 1 { // assume bool, set as true
val = tr... | go | {
"resource": ""
} |
q173169 | doDec | validation | func doDec(signer jwt.Signer, in []byte) ([]byte, error) {
var err error
// decode token
ut := UnstructuredToken{}
err = signer.Decode(bytes.TrimSpace(in), &ut)
if err != nil {
return nil, err
}
// pretty format output
out, err := json.MarshalIndent(&ut, "", " ")
if err != nil {
return nil, err
}
ret... | go | {
"resource": ""
} |
q173170 | doEnc | validation | func doEnc(signer jwt.Signer, in []byte) ([]byte, error) {
var err error
// make sure its valid json first
m := make(map[string]interface{})
// do the initial decode
d := json.NewDecoder(bytes.NewBuffer(in))
d.UseNumber()
err = d.Decode(&m)
if err != nil {
return nil, err
}
// encode claims
out, err := ... | go | {
"resource": ""
} |
q173171 | Transport | validation | func Transport(transport http.RoundTripper) Option {
return func(gsa *GServiceAccount) error {
gsa.transport = transport
return nil
}
} | go | {
"resource": ""
} |
q173172 | Proxy | validation | func Proxy(proxy string) Option {
return func(gsa *GServiceAccount) error {
u, err := url.Parse(proxy)
if err != nil {
return err
}
return Transport(&http.Transport{
Proxy: http.ProxyURL(u),
})(gsa)
}
} | go | {
"resource": ""
} |
q173173 | Expiration | validation | func Expiration(expiration time.Duration) Option {
return func(gsa *GServiceAccount) error {
gsa.expiration = expiration
return nil
}
} | go | {
"resource": ""
} |
q173174 | Encode | validation | func Encode(alg Algorithm, signer Signer, obj interface{}) ([]byte, error) {
var err error
// grab encode targets
headerObj, payloadObj, err := encodeTargets(alg, obj)
if err != nil {
return nil, err
}
// json encode header
header, err := json.Marshal(headerObj)
if err != nil {
return nil, err
}
// b64... | go | {
"resource": ""
} |
q173175 | PeekHeaderField | validation | func PeekHeaderField(buf []byte, field string) (string, error) {
return peekField(buf, field, tokenPositionHeader)
} | go | {
"resource": ""
} |
q173176 | PeekAlgorithm | validation | func PeekAlgorithm(buf []byte) (Algorithm, error) {
alg := NONE
// get alg
algVal, err := PeekHeaderField(buf, "alg")
if err != nil {
return NONE, err
}
// decode alg
err = (&alg).UnmarshalText([]byte(algVal))
if err != nil {
return NONE, err
}
return alg, nil
} | go | {
"resource": ""
} |
q173177 | PeekAlgorithmAndIssuer | validation | func PeekAlgorithmAndIssuer(buf []byte) (Algorithm, string, error) {
var err error
// get algorithm
alg, err := PeekAlgorithm(buf)
if err != nil {
return NONE, "", err
}
// get issuer
issuer, err := PeekPayloadField(buf, "iss")
if err != nil {
return NONE, "", err
}
return alg, issuer, nil
} | go | {
"resource": ""
} |
q173178 | NewEllipticSigner | validation | func NewEllipticSigner(alg Algorithm, curve elliptic.Curve) func(Store, crypto.Hash) (Signer, error) {
curveBitSize := curve.Params().BitSize
// precompute curve key len
keyLen := curveBitSize / 8
if curveBitSize%8 > 0 {
keyLen++
}
return func(store Store, hash crypto.Hash) (Signer, error) {
var ok bool
v... | go | {
"resource": ""
} |
q173179 | NewTokenSource | validation | func NewTokenSource(signer jwt.Signer, tokenURL string, ctxt context.Context, opts ...Option) (*Bearer, error) {
var err error
b := &Bearer{
signer: signer,
tokenURL: tokenURL,
context: ctxt,
claims: make(map[string]interface{}),
}
// apply opts
for _, o := range opts {
if err = o(b); err != nil {... | go | {
"resource": ""
} |
q173180 | Client | validation | func (b *Bearer) Client() *http.Client {
return &http.Client{
Transport: &oauth2.Transport{
Source: b,
},
}
} | go | {
"resource": ""
} |
q173181 | Sign | validation | func (r RSAMethod) Sign(rand io.Reader, priv *rsa.PrivateKey, hash crypto.Hash, buf []byte) ([]byte, error) {
return r.SignFunc(rand, priv, hash, buf)
} | go | {
"resource": ""
} |
q173182 | Verify | validation | func (r RSAMethod) Verify(pub *rsa.PublicKey, hash crypto.Hash, hashed []byte, sig []byte) error {
return r.VerifyFunc(pub, hash, hashed, sig)
} | go | {
"resource": ""
} |
q173183 | NewRSASigner | validation | func NewRSASigner(alg Algorithm, method RSASignerVerifier) func(Store, crypto.Hash) (Signer, error) {
return func(store Store, hash crypto.Hash) (Signer, error) {
var ok bool
var privRaw, pubRaw interface{}
var priv *rsa.PrivateKey
var pub *rsa.PublicKey
// check private key
if privRaw, ok = store.Private... | go | {
"resource": ""
} |
q173184 | getFieldWithTag | validation | func getFieldWithTag(obj interface{}, tagName string) *reflect.Value {
objVal := reflect.ValueOf(obj)
if objVal.Kind() != reflect.Struct {
objVal = objVal.Elem()
}
for i := 0; i < objVal.NumField(); i++ {
fieldType := objVal.Type().Field(i)
if tagName == fieldType.Tag.Get("jwt") {
field := objVal.Field(i)... | go | {
"resource": ""
} |
q173185 | decodeToObjOrFieldWithTag | validation | func decodeToObjOrFieldWithTag(buf []byte, obj interface{}, tagName string, defaultObj interface{}) error {
// reflect values
objValElem := reflect.ValueOf(obj).Elem()
defaultObjValElem := reflect.ValueOf(defaultObj).Elem()
// first check type, if same type, then set
if objValElem.Type() == defaultObjValElem.Type... | go | {
"resource": ""
} |
q173186 | grabEncodeTargets | validation | func grabEncodeTargets(alg Algorithm, obj interface{}) (interface{}, interface{}, error) {
var headerObj, payloadObj interface{}
// get header
if headerVal := getFieldWithTag(obj, "header"); headerVal != nil {
headerObj = headerVal.Interface()
}
if headerObj == nil {
headerObj = alg.Header()
}
// get paylo... | go | {
"resource": ""
} |
q173187 | encodeTargets | validation | func encodeTargets(alg Algorithm, obj interface{}) (interface{}, interface{}, error) {
// determine what to encode
switch val := obj.(type) {
case *Token:
return val.Header, val.Payload, nil
}
objVal := reflect.ValueOf(obj)
objKind := objVal.Kind()
if objKind == reflect.Struct || (objKind == reflect.Ptr && ob... | go | {
"resource": ""
} |
q173188 | peekField | validation | func peekField(buf []byte, fieldName string, pos tokenPosition) (string, error) {
var err error
// split token
ut := UnverifiedToken{}
err = DecodeUnverifiedToken(buf, &ut)
if err != nil {
return "", err
}
// determine position decode
var typ string
var b []byte
switch pos {
case tokenPositionHeader:
t... | go | {
"resource": ""
} |
q173189 | ExpiresIn | validation | func ExpiresIn(d time.Duration) Option {
return func(tok *Bearer) error {
if d != 0 {
tok.addExpiration = true
tok.expiresIn = d
} else {
tok.addExpiration = false
tok.expiresIn = 0
}
return nil
}
} | go | {
"resource": ""
} |
q173190 | Claim | validation | func Claim(name string, v interface{}) Option {
return func(tok *Bearer) error {
if tok.claims == nil {
return errors.New("attempting to add claim to improperly created token")
}
tok.claims[name] = v
return nil
}
} | go | {
"resource": ""
} |
q173191 | Transport | validation | func Transport(transport http.RoundTripper) Option {
return func(tok *Bearer) error {
tok.transport = transport
return nil
}
} | go | {
"resource": ""
} |
q173192 | NewHMACSigner | validation | func NewHMACSigner(alg Algorithm) func(Store, crypto.Hash) (Signer, error) {
return func(store Store, hash crypto.Hash) (Signer, error) {
var ok bool
var keyRaw interface{}
var key []byte
// check private key
if keyRaw, ok = store.PrivateKey(); !ok {
return nil, ErrMissingPrivateKey
}
// check key t... | go | {
"resource": ""
} |
q173193 | FromJSON | validation | func FromJSON(buf []byte, opts ...Option) (*GServiceAccount, error) {
var err error
// unmarshal
gsa := new(GServiceAccount)
if err = json.Unmarshal(buf, gsa); err != nil {
return nil, err
}
// apply opts
for _, o := range opts {
if err = o(gsa); err != nil {
return nil, err
}
}
return gsa, nil
} | go | {
"resource": ""
} |
q173194 | FromReader | validation | func FromReader(r io.Reader, opts ...Option) (*GServiceAccount, error) {
buf, err := ioutil.ReadAll(r)
if err != nil {
return nil, err
}
return FromJSON(buf, opts...)
} | go | {
"resource": ""
} |
q173195 | FromFile | validation | func FromFile(path string, opts ...Option) (*GServiceAccount, error) {
buf, err := ioutil.ReadFile(path)
if err != nil {
return nil, err
}
return FromJSON(buf, opts...)
} | go | {
"resource": ""
} |
q173196 | Signer | validation | func (gsa *GServiceAccount) Signer() (jwt.Signer, error) {
gsa.mu.Lock()
defer gsa.mu.Unlock()
if gsa.signer == nil {
keyset, err := pemutil.DecodeBytes([]byte(gsa.PrivateKey))
if err != nil {
return nil, fmt.Errorf("jwt/gserviceaccount: could not decode private key: %v", err)
}
keyset.AddPublicKeys()
... | go | {
"resource": ""
} |
q173197 | Encode | validation | func (alg Algorithm) Encode(signer Signer, obj interface{}) ([]byte, error) {
return Encode(alg, signer, obj)
} | go | {
"resource": ""
} |
q173198 | UnmarshalText | validation | func (alg *Algorithm) UnmarshalText(buf []byte) error {
switch string(buf) {
// hmac
case "HS256":
*alg = HS256
case "HS384":
*alg = HS384
case "HS512":
*alg = HS512
// rsa-pkcs1v15
case "RS256":
*alg = RS256
case "RS384":
*alg = RS384
case "RS512":
*alg = RS512
// ecc
case "ES256":
*alg = ES... | go | {
"resource": ""
} |
q173199 | DecodeUnverifiedToken | validation | func DecodeUnverifiedToken(buf []byte, ut *UnverifiedToken) error {
b := bytes.Split(buf, tokenSep)
if len(b) != 3 {
return ErrInvalidToken
}
ut.Header = b[0]
ut.Payload = b[1]
ut.Signature = b[2]
return nil
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.