// GetAssignedMarkVal -- returns the mark val assigned to the group
329653
func GetAssignedMarkVal(cgroupName string) string {
	mark, err := ioutil.ReadFile(filepath.Join(basePath, TriremeBasePath, cgroupName, markFile))

	if err != nil || len(mark) < 1 {
		zap.L().Error("Unable to read markval for cgroup", zap.String("Cgroup Name", cgroupName), zap.Error(err))
		return ""
	}
	return string(mark[:len(mark)-1])
}
881991
func (s storageclient) GetSignedURLs(context.Context, *coordinator.URLSigningRequest) (*coordinator.URLSigningResponse, error) {
	return nil, errors.New("NOT IMPLEMENTED")
}
1181964
func (si SignerInfo) GetSigningTimeAttribute() (time.Time, error) {
	var t time.Time

	if !si.SignedAttrs.HasAttribute(oid.AttributeSigningTime) {
		return t, nil
	}
	rv, err := si.SignedAttrs.GetOnlyAttributeValueBytes(oid.AttributeSigningTime)
	if err != nil {
		return t, err
	}
	if rv.Class != asn1.ClassUniversal || (rv.Tag != asn1.TagUTCTime && rv.Tag != asn1.TagGeneralizedTime) {
		return t, ASN1Error{"bad class or tag"}
	}

	if rest, err := asn1.Unmarshal(rv.FullBytes, &t); err != nil {
		return t, err
	} else if len(rest) > 0 {
		return t, ErrTrailingData
	}

	return t, nil
}
46752
func getSignature(signingKey []byte, stringToSign string) string {
	return hex.EncodeToString(sumHMAC(signingKey, []byte(stringToSign)))
}
656118
func (i *IssueRequest) GetAssignees() []string {
	if i == nil || i.Assignees == nil {
		return nil
	}
	return *i.Assignees
}
464543
func (s *SignatureVerification) GetSignature() string {
	if s == nil || s.Signature == nil {
		return ""
	}
	return *s.Signature
}
326128
func (f *FakeProcTableImpl) MarkFailed(pvName string) error {
	f.MarkDoneCount++
	return f.realTable.MarkFailed(pvName)
}
236810
func (c *Client) GetSignupTokenData(token string) (user string, otpQRCode []byte, e error) {
	out, err := c.Get(c.Endpoint("signuptokens", token), url.Values{})
	if err != nil {
		return "", nil, err
	}

	var tokenData getSignupTokenDataResponse
	if err := json.Unmarshal(out.Bytes(), &tokenData); err != nil {
		return "", nil, err
	}

	return tokenData.User, tokenData.QRImg, nil
}
457562
func (cc *Controller) graduateAssignedToLastKnownGood() error {
	// get assigned
	assigned, err := cc.checkpointStore.Assigned()
	if err != nil {
		return err
	}
	// get last-known-good
	lastKnownGood, err := cc.checkpointStore.LastKnownGood()
	if err != nil {
		return err
	}
	// if the sources are equal, no need to change
	if assigned == lastKnownGood ||
		assigned != nil && lastKnownGood != nil && apiequality.Semantic.DeepEqual(assigned.NodeConfigSource(), lastKnownGood.NodeConfigSource()) {
		return nil
	}
	// update last-known-good
	err = cc.checkpointStore.SetLastKnownGood(assigned)
	if err != nil {
		return err
	}
	// update the status to reflect the new last-known-good config
	cc.configStatus.SetLastKnownGood(assigned.NodeConfigSource())
	utillog.Infof("updated last-known-good config to %s, UID: %s, ResourceVersion: %s", assigned.APIPath(), assigned.UID(), assigned.ResourceVersion())
	return nil
}
636305
func IsSigned(t querypb.Type) bool {
	return int(t)&(flagIsIntegral|flagIsUnsigned) == flagIsIntegral
}
1349780
func (j *RS256JWTStrategy) GetSignature(ctx context.Context, token string) (string, error) {
	split := strings.Split(token, ".")
	if len(split) != 3 {
		return "", errors.New("Header, body and signature must all be set")
	}
	return split[2], nil
}
1030438
func (ma *markAllocator) get() (uint32, error) {
	ma.lock.Lock()
	defer ma.lock.Unlock()
	if len(ma.marks) == 0 {
		return 0, errors.New("allocator exhausted")
	}
	mark := ma.marks[0]
	ma.marks = ma.marks[1:]
	return mark, nil
}
1082404
func (km *KeyManager) MarkKeyAsUsed(scriptAddress []byte) error {
	if err := km.datastore.MarkKeyAsUsed(scriptAddress); err != nil {
		return err
	}
	return km.lookahead()
}
964121
func MarkTaskSucceeded(t *automationpb.Task, output string) {
	t.State = automationpb.TaskState_DONE
	t.Output = output
}
133715
func (a Annotation) getVal(key string) (string, bool) {
	v, ok := a[key]
	return v, ok
}
430859
func getValueInDir(dir *etcd.Node, key string) (value string) {
	valPath := path.Join(dir.Key, key)
	for _, node := range dir.Nodes {
		if node.Key == valPath {
			value = node.Value
			break
		}
	}
	return
}
169132
func markQualifiedForAutoHTTPS(configs []*SiteConfig) {
	for _, cfg := range configs {
		if caddytls.QualifiesForManagedTLS(cfg) && cfg.Addr.Scheme != "http" {
			cfg.TLS.Managed = true
		}
	}
}