code stringlengths 31 2.05k | label_name stringclasses 5 values | label int64 0 4 |
|---|---|---|
func GetDNSKey() string {
key := "secretkey"
if os.Getenv("DNS_KEY") != "" {
key = os.Getenv("DNS_KEY")
} else if config.Config.Server.DNSKey != "" {
key = config.Config.Server.DNSKey
}
return key
} | Base | 1 |
err = sigRepo.ListSignatures(ctx, manifestDesc, func(signatureManifests []ocispec.Descriptor) error {
for _, sigManifestDesc := range signatureManifests {
sigBlob, sigDesc, err := sigRepo.FetchSignatureBlob(ctx, sigManifestDesc)
if err != nil {
fmt.Fprintf(os.Stderr, "Warning: unable to fetch signature %s due to error: %v\n", sigManifestDesc.Digest.String(), err)
skippedSignatures = true
continue
}
sigEnvelope, err := signature.ParseEnvelope(sigDesc.MediaType, sigBlob)
if err != nil {
logSkippedSignature(sigManifestDesc, err)
skippedSignatures = true
continue
}
envelopeContent, err := sigEnvelope.Content()
if err != nil {
logSkippedSignature(sigManifestDesc, err)
skippedSignatures = true
continue
}
signedArtifactDesc, err := envelope.DescriptorFromSignaturePayload(&envelopeContent.Payload)
if err != nil {
logSkippedSignature(sigManifestDesc, err)
skippedSignatures = true
continue
}
signatureAlgorithm, err := proto.EncodeSigningAlgorithm(envelopeContent.SignerInfo.SignatureAlgorithm)
if err != nil {
logSkippedSignature(sigManifestDesc, err)
skippedSignatures = true
continue
}
sig := signatureOutput{
MediaType: sigDesc.MediaType,
Digest: sigManifestDesc.Digest.String(),
SignatureAlgorithm: string(signatureAlgorithm),
SignedAttributes: getSignedAttributes(opts.outputFormat, envelopeContent),
UserDefinedAttributes: signedArtifactDesc.Annotations,
UnsignedAttributes: getUnsignedAttributes(envelopeContent),
Certificates: getCertificates(opts.outputFormat, envelopeContent),
SignedArtifact: *signedArtifactDesc,
}
// clearing annotations from the SignedArtifact field since they're already
// displayed as UserDefinedAttributes
sig.SignedArtifact.Annotations = nil
output.Signatures = append(output.Signatures, sig)
}
return nil
}) | Class | 2 |
func TestInspectCommand_SecretsFromArgs(t *testing.T) {
opts := &inspectOpts{}
command := inspectCommand(opts)
expected := &inspectOpts{
reference: "ref",
SecureFlagOpts: SecureFlagOpts{
Password: "password",
InsecureRegistry: true,
Username: "user",
},
outputFormat: cmd.OutputPlaintext,
}
if err := command.ParseFlags([]string{
"--password", expected.Password,
expected.reference,
"-u", expected.Username,
"--insecure-registry",
"--output", "text"}); err != nil {
t.Fatalf("Parse Flag failed: %v", err)
}
if err := command.Args(command, command.Flags().Args()); err != nil {
t.Fatalf("Parse Args failed: %v", err)
}
if *opts != *expected {
t.Fatalf("Expect inspect opts: %v, got: %v", expected, opts)
}
} | Class | 2 |
func TestInspectCommand_SecretsFromEnv(t *testing.T) {
t.Setenv(defaultUsernameEnv, "user")
t.Setenv(defaultPasswordEnv, "password")
opts := &inspectOpts{}
expected := &inspectOpts{
reference: "ref",
SecureFlagOpts: SecureFlagOpts{
Password: "password",
Username: "user",
},
outputFormat: cmd.OutputJSON,
}
command := inspectCommand(opts)
if err := command.ParseFlags([]string{
expected.reference,
"--output", "json"}); err != nil {
t.Fatalf("Parse Flag failed: %v", err)
}
if err := command.Args(command, command.Flags().Args()); err != nil {
t.Fatalf("Parse Args failed: %v", err)
}
if *opts != *expected {
t.Fatalf("Expect inspect opts: %v, got: %v", expected, opts)
}
} | Class | 2 |
func runList(ctx context.Context, opts *listOpts) error {
// set log level
ctx = opts.LoggingFlagOpts.SetLoggerLevel(ctx)
// initialize
reference := opts.reference
sigRepo, err := getRepository(ctx, opts.inputType, reference, &opts.SecureFlagOpts, opts.allowReferrersAPI)
if err != nil {
return err
}
targetDesc, resolvedRef, err := resolveReferenceWithWarning(ctx, opts.inputType, reference, sigRepo, "list")
if err != nil {
return err
}
// print all signature manifest digests
return printSignatureManifestDigests(ctx, targetDesc, sigRepo, resolvedRef)
} | Class | 2 |
err := sigRepo.ListSignatures(ctx, targetDesc, func(signatureManifests []ocispec.Descriptor) error {
for _, sigManifestDesc := range signatureManifests {
if prevDigest != "" {
// check and print title
printTitle()
// print each signature digest
fmt.Printf(" ├── %s\n", prevDigest)
}
prevDigest = sigManifestDesc.Digest
}
return nil
}) | Class | 2 |
func runVerify(command *cobra.Command, opts *verifyOpts) error {
// set log level
ctx := opts.LoggingFlagOpts.SetLoggerLevel(command.Context())
// initialize
sigVerifier, err := verifier.NewFromConfig()
if err != nil {
return err
}
// set up verification plugin config.
configs, err := cmd.ParseFlagMap(opts.pluginConfig, cmd.PflagPluginConfig.Name)
if err != nil {
return err
}
// set up user metadata
userMetadata, err := cmd.ParseFlagMap(opts.userMetadata, cmd.PflagUserMetadata.Name)
if err != nil {
return err
}
// core verify process
reference := opts.reference
sigRepo, err := getRepository(ctx, opts.inputType, reference, &opts.SecureFlagOpts, opts.allowReferrersAPI)
if err != nil {
return err
}
// resolve the given reference and set the digest
_, resolvedRef, err := resolveReferenceWithWarning(ctx, opts.inputType, reference, sigRepo, "verify")
if err != nil {
return err
}
intendedRef := resolveArtifactDigestReference(resolvedRef, opts.trustPolicyScope)
verifyOpts := notation.VerifyOptions{
ArtifactReference: intendedRef,
PluginConfig: configs,
// TODO: need to change MaxSignatureAttempts as a user input flag or
// a field in config.json
MaxSignatureAttempts: maxSignatureAttempts,
UserMetadata: userMetadata,
}
_, outcomes, err := notation.Verify(ctx, sigVerifier, sigRepo, verifyOpts)
err = checkVerificationFailure(outcomes, resolvedRef, err)
if err != nil {
return err
}
reportVerificationSuccess(outcomes, resolvedRef)
return nil
} | Class | 2 |
func TestVerifyCommand_BasicArgs(t *testing.T) {
opts := &verifyOpts{}
command := verifyCommand(opts)
expected := &verifyOpts{
reference: "ref",
SecureFlagOpts: SecureFlagOpts{
Username: "user",
Password: "password",
},
pluginConfig: []string{"key1=val1"},
}
if err := command.ParseFlags([]string{
expected.reference,
"--username", expected.Username,
"--password", expected.Password,
"--plugin-config", "key1=val1"}); err != nil {
t.Fatalf("Parse Flag failed: %v", err)
}
if err := command.Args(command, command.Flags().Args()); err != nil {
t.Fatalf("Parse args failed: %v", err)
}
if !reflect.DeepEqual(*expected, *opts) {
t.Fatalf("Expect verify opts: %v, got: %v", expected, opts)
}
} | Class | 2 |
func TestVerifyCommand_MoreArgs(t *testing.T) {
opts := &verifyOpts{}
command := verifyCommand(opts)
expected := &verifyOpts{
reference: "ref",
SecureFlagOpts: SecureFlagOpts{
InsecureRegistry: true,
},
pluginConfig: []string{"key1=val1", "key2=val2"},
}
if err := command.ParseFlags([]string{
expected.reference,
"--insecure-registry",
"--plugin-config", "key1=val1",
"--plugin-config", "key2=val2"}); err != nil {
t.Fatalf("Parse Flag failed: %v", err)
}
if err := command.Args(command, command.Flags().Args()); err != nil {
t.Fatalf("Parse args failed: %v", err)
}
if !reflect.DeepEqual(*expected, *opts) {
t.Fatalf("Expect verify opts: %v, got: %v", expected, opts)
}
} | Class | 2 |
func NewQUICServer(addr, password, domain string, tcpTimeout, udpTimeout int, blockDomainList, blockCIDR4List, blockCIDR6List string, updateListInterval int64, blockGeoIP []string, withoutbrook bool) (*QUICServer, error) {
if err := limits.Raise(); err != nil {
Log(&Error{"when": "try to raise system limits", "warning": err.Error()})
}
if runtime.GOOS == "linux" {
c := exec.Command("sysctl", "-w", "net.core.rmem_max=2500000")
b, err := c.CombinedOutput()
if err != nil {
Log(&Error{"when": "try to raise UDP Receive Buffer Size", "warning": string(b)})
}
}
if runtime.GOOS == "darwin" {
c := exec.Command("sysctl", "-w", "kern.ipc.maxsockbuf=3014656")
b, err := c.CombinedOutput()
if err != nil {
Log(&Error{"when": "try to raise UDP Receive Buffer Size", "warning": string(b)})
}
}
var p []byte
var f UDPServerConnFactory
if !withoutbrook {
p = []byte(password)
f = NewPacketServerConnFactory()
}
if withoutbrook {
var err error
p, err = crypto1.SHA256Bytes([]byte(password))
if err != nil {
return nil, err
}
f = NewSimplePacketServerConnFactory()
}
s := &QUICServer{
Password: p,
Domain: domain,
Addr: addr,
TCPTimeout: tcpTimeout,
UDPTimeout: udpTimeout,
UDPServerConnFactory: f,
RunnerGroup: runnergroup.New(),
WithoutBrook: withoutbrook,
}
return s, nil
} | Base | 1 |
func (c *StreamClient) Exchange(local net.Conn) error {
go func() {
for {
if c.Timeout != 0 {
if err := c.Server.SetDeadline(time.Now().Add(time.Duration(c.Timeout) * time.Second)); err != nil {
return
}
}
l, err := c.ReadL()
if err != nil {
return
}
if _, err := local.Write(c.RB[2+16 : 2+16+l]); err != nil {
return
}
}
}()
for {
if c.Timeout != 0 {
if err := local.SetDeadline(time.Now().Add(time.Duration(c.Timeout) * time.Second)); err != nil {
return nil
}
}
l, err := local.Read(c.WB[2+16 : len(c.WB)-16])
if err != nil {
return nil
}
if err := c.WriteL(l); err != nil {
return nil
}
}
return nil
} | Base | 1 |
func (c *StreamClient) ReadL() (int, error) {
if _, err := io.ReadFull(c.Server, c.RB[:2+16]); err != nil {
return 0, err
}
if _, err := c.sa.Open(c.RB[:0], c.sn, c.RB[:2+16], nil); err != nil {
return 0, err
}
l := int(binary.BigEndian.Uint16(c.RB[:2]))
if _, err := io.ReadFull(c.Server, c.RB[2+16:2+16+l+16]); err != nil {
return 0, err
}
NextNonce(c.sn)
if _, err := c.sa.Open(c.RB[:2+16], c.sn, c.RB[2+16:2+16+l+16], nil); err != nil {
return 0, err
}
NextNonce(c.sn)
return l, nil
} | Base | 1 |
func (c *StreamClient) WriteL(l int) error {
binary.BigEndian.PutUint16(c.WB[:2], uint16(l))
c.ca.Seal(c.WB[:0], c.cn, c.WB[:2], nil)
NextNonce(c.cn)
c.ca.Seal(c.WB[:2+16], c.cn, c.WB[2+16:2+16+l], nil)
if _, err := c.Server.Write(c.WB[:2+16+l+16]); err != nil {
return err
}
NextNonce(c.cn)
return nil
} | Base | 1 |
func (r *MySQL) Probe() (bool, string) {
if r.tls != nil {
mysql.RegisterTLSConfig(global.DefaultProg, r.tls)
}
db, err := sql.Open("mysql", r.ConnStr)
if err != nil {
return false, err.Error()
}
defer db.Close()
// Check if we need to query specific data
if len(r.Data) > 0 {
for k, v := range r.Data {
log.Debugf("[%s / %s / %s] - Verifying Data - [%s] : [%s]", r.ProbeKind, r.ProbeName, r.ProbeTag, k, v)
sql, err := r.getSQL(k)
if err != nil {
return false, err.Error()
}
log.Debugf("[%s / %s / %s] - SQL - [%s]", r.ProbeKind, r.ProbeName, r.ProbeTag, sql)
rows, err := db.Query(sql)
if err != nil {
return false, err.Error()
}
if !rows.Next() {
rows.Close()
return false, fmt.Sprintf("No data found for [%s]", k)
}
//check the value is equal to the value in data
var value string
if err := rows.Scan(&value); err != nil {
rows.Close()
return false, err.Error()
}
if value != v {
rows.Close()
return false, fmt.Sprintf("Value not match for [%s] expected [%s] got [%s] ", k, v, value)
}
rows.Close()
log.Debugf("[%s / %s / %s] - Data Verified Successfully! - [%s] : [%s]", r.ProbeKind, r.ProbeName, r.ProbeTag, k, v)
}
} else {
err = db.Ping()
if err != nil {
return false, err.Error()
}
row, err := db.Query("show status like \"uptime\"") // run a SQL to test
if err != nil {
return false, err.Error()
}
defer row.Close()
}
return true, "Check MySQL Server Successfully!"
} | Base | 1 |
func (r *MySQL) getSQL(str string) (string, error) {
if len(strings.TrimSpace(str)) == 0 {
return "", fmt.Errorf("Empty SQL data")
}
fields := strings.Split(str, ":")
if len(fields) != 5 {
return "", fmt.Errorf("Invalid SQL data - [%s]. (syntax: database:table:field:key:value)", str)
}
db := fields[0]
table := fields[1]
field := fields[2]
key := fields[3]
value := fields[4]
//check value is int or not
if _, err := strconv.Atoi(value); err != nil {
return "", fmt.Errorf("Invalid SQL data - [%s], the value must be int", str)
}
sql := fmt.Sprintf("SELECT %s FROM %s.%s WHERE %s = %s", field, db, table, key, value)
return sql, nil
} | Base | 1 |
func (r *PostgreSQL) getSQL(str string) (string, string, error) {
if len(strings.TrimSpace(str)) == 0 {
return "", "", fmt.Errorf("Empty SQL data")
}
fields := strings.Split(str, ":")
if len(fields) != 5 {
return "", "", fmt.Errorf("Invalid SQL data - [%s]. (syntax: database:table:field:key:value)", str)
}
db := fields[0]
table := fields[1]
field := fields[2]
key := fields[3]
value := fields[4]
//check value is int or not
if _, err := strconv.Atoi(value); err != nil {
return "", "", fmt.Errorf("Invalid SQL data - [%s], the value must be int", str)
}
sql := fmt.Sprintf("SELECT %s FROM %s WHERE %s = %s", field, table, key, value)
return db, sql, nil
} | Base | 1 |
func (v *SnapshotJob) do(ffmpegPath, inputUrl string) (err error) {
outputPicDir := path.Join(StaticDir, v.App)
if err = os.MkdirAll(outputPicDir, 0777); err != nil {
log.Println(fmt.Sprintf("create snapshot image dir:%v failed, err is %v", outputPicDir, err))
return
}
normalPicPath := path.Join(outputPicDir, fmt.Sprintf("%v", v.Stream)+"-%03d.png")
bestPng := path.Join(outputPicDir, fmt.Sprintf("%v-best.png", v.Stream))
param := fmt.Sprintf("%v -i %v -vf fps=1 -vcodec png -f image2 -an -y -vframes %v -y %v", ffmpegPath, inputUrl, v.vframes, normalPicPath)
log.Println(fmt.Sprintf("start snapshot, cmd param=%v", param))
timeoutCtx, _ := context.WithTimeout(v.cancelCtx, v.timeout)
cmd := exec.CommandContext(timeoutCtx, "/bin/bash", "-c", param)
if err = cmd.Run(); err != nil {
log.Println(fmt.Sprintf("run snapshot %v cmd failed, err is %v", v.Tag(), err))
return
}
bestFileSize := int64(0)
for i := 1; i <= v.vframes; i++ {
pic := path.Join(outputPicDir, fmt.Sprintf("%v-%03d.png", v.Stream, i))
fi, err := os.Stat(pic)
if err != nil {
log.Println(fmt.Sprintf("stat pic:%v failed, err is %v", pic, err))
continue
}
if bestFileSize == 0 {
bestFileSize = fi.Size()
} else if fi.Size() > bestFileSize {
os.Remove(bestPng)
os.Symlink(pic, bestPng)
bestFileSize = fi.Size()
}
}
log.Println(fmt.Sprintf("%v the best thumbnail is %v", v.Tag(), bestPng))
return
} | Class | 2 |
func (r *TerraformRunnerServer) NewTerraform(ctx context.Context, req *NewTerraformRequest) (*NewTerraformReply, error) {
r.InstanceID = req.GetInstanceID()
log := ctrl.LoggerFrom(ctx, "instance-id", r.InstanceID).WithName(loggerName)
log.Info("creating new terraform", "workingDir", req.WorkingDir, "execPath", req.ExecPath)
tf, err := tfexec.NewTerraform(req.WorkingDir, req.ExecPath)
if err != nil {
log.Error(err, "unable to create new terraform", "workingDir", req.WorkingDir, "execPath", req.ExecPath)
return nil, err
}
// hold only 1 instance
r.tf = tf
var terraform infrav1.Terraform
if err := terraform.FromBytes(req.Terraform, r.Scheme); err != nil {
log.Error(err, "there was a problem getting the terraform resource")
return nil, err
}
// cache the Terraform resource when initializing
r.terraform = &terraform
disableTestLogging := os.Getenv("DISABLE_TF_LOGS") == "1"
if !disableTestLogging {
r.tf.SetStdout(os.Stdout)
r.tf.SetStderr(os.Stderr)
if os.Getenv("ENABLE_SENSITIVE_TF_LOGS") == "1" {
r.tf.SetLogger(&LocalPrintfer{logger: log})
}
}
return &NewTerraformReply{Id: r.InstanceID}, nil
} | Class | 2 |
func (r *TerraformRunnerServer) Plan(ctx context.Context, req *PlanRequest) (*PlanReply, error) {
log := controllerruntime.LoggerFrom(ctx, "instance-id", r.InstanceID).WithName(loggerName)
log.Info("creating a plan")
ctx, cancel := context.WithCancel(ctx)
go func() {
select {
case <-r.Done:
cancel()
case <-ctx.Done():
}
}()
if req.TfInstance != r.InstanceID {
err := fmt.Errorf("no TF instance found")
log.Error(err, "no terraform")
return nil, err
}
var planOpt []tfexec.PlanOption
if req.Out != "" {
planOpt = append(planOpt, tfexec.Out(req.Out))
} else {
// if backend is disabled completely, there will be no plan output file (req.Out = "")
log.Info("backend seems to be disabled completely, so there will be no plan output file")
}
if req.Refresh == false {
planOpt = append(planOpt, tfexec.Refresh(req.Refresh))
}
if req.Destroy {
planOpt = append(planOpt, tfexec.Destroy(req.Destroy))
}
for _, target := range req.Targets {
planOpt = append(planOpt, tfexec.Target(target))
}
drifted, err := r.tf.Plan(ctx, planOpt...)
if err != nil {
st := status.New(codes.Internal, err.Error())
var stateErr *tfexec.ErrStateLocked
if errors.As(err, &stateErr) {
st, err = st.WithDetails(&PlanReply{Message: "not ok", StateLockIdentifier: stateErr.ID})
if err != nil {
return nil, err
}
}
log.Error(err, "error creating the plan")
return nil, st.Err()
}
planCreated := false
if req.Out != "" {
planCreated = true
plan, err := r.tf.ShowPlanFile(ctx, req.Out)
if err != nil {
return nil, err
}
// This is the case when the plan is empty.
if plan.PlannedValues.Outputs == nil &&
plan.PlannedValues.RootModule.Resources == nil &&
plan.ResourceChanges == nil &&
plan.PriorState == nil &&
plan.OutputChanges == nil {
planCreated = false
}
}
return &PlanReply{Message: "ok", Drifted: drifted, PlanCreated: planCreated}, nil
} | Class | 2 |
func (r *TerraformRunnerServer) SaveTFPlan(ctx context.Context, req *SaveTFPlanRequest) (*SaveTFPlanReply, error) {
log := controllerruntime.LoggerFrom(ctx, "instance-id", r.InstanceID).WithName(loggerName)
log.Info("save the plan")
if req.TfInstance != r.InstanceID {
err := fmt.Errorf("no TF instance found")
log.Error(err, "no terraform")
return nil, err
}
var tfplan []byte
if req.BackendCompletelyDisable {
tfplan = []byte("dummy plan")
} else {
var err error
tfplan, err = ioutil.ReadFile(filepath.Join(r.tf.WorkingDir(), TFPlanName))
if err != nil {
err = fmt.Errorf("error reading plan file: %s", err)
log.Error(err, "unable to complete SaveTFPlan function")
return nil, err
}
}
planRev := strings.Replace(req.Revision, "/", "-", 1)
planName := "plan-" + planRev
if err := r.writePlanAsSecret(ctx, req.Name, req.Namespace, log, planName, tfplan, "", req.Uuid); err != nil {
return nil, err
}
if r.terraform.Spec.StoreReadablePlan == "json" {
planObj, err := r.tf.ShowPlanFile(ctx, TFPlanName)
if err != nil {
log.Error(err, "unable to get the plan output for json")
return nil, err
}
jsonBytes, err := json.Marshal(planObj)
if err != nil {
log.Error(err, "unable to marshal the plan to json")
return nil, err
}
if err := r.writePlanAsSecret(ctx, req.Name, req.Namespace, log, planName, jsonBytes, ".json", req.Uuid); err != nil {
return nil, err
}
} else if r.terraform.Spec.StoreReadablePlan == "human" {
rawOutput, err := r.tf.ShowPlanFileRaw(ctx, TFPlanName)
if err != nil {
log.Error(err, "unable to get the plan output for human")
return nil, err
}
if err := r.writePlanAsConfigMap(ctx, req.Name, req.Namespace, log, planName, rawOutput, "", req.Uuid); err != nil {
return nil, err
}
}
return &SaveTFPlanReply{Message: "ok"}, nil
} | Class | 2 |
func (r *TerraformRunnerServer) ShowPlanFileRaw(ctx context.Context, req *ShowPlanFileRawRequest) (*ShowPlanFileRawReply, error) {
log := controllerruntime.LoggerFrom(ctx, "instance-id", r.InstanceID).WithName(loggerName)
log.Info("show the raw plan file")
if req.TfInstance != r.InstanceID {
err := fmt.Errorf("no TF instance found")
log.Error(err, "no terraform")
return nil, err
}
rawOutput, err := r.tf.ShowPlanFileRaw(ctx, req.Filename)
if err != nil {
log.Error(err, "unable to get the raw plan output")
return nil, err
}
return &ShowPlanFileRawReply{RawOutput: rawOutput}, nil
} | Class | 2 |
func (r *TerraformRunnerServer) ShowPlanFile(ctx context.Context, req *ShowPlanFileRequest) (*ShowPlanFileReply, error) {
log := controllerruntime.LoggerFrom(ctx, "instance-id", r.InstanceID).WithName(loggerName)
log.Info("show the raw plan file")
if req.TfInstance != r.InstanceID {
err := fmt.Errorf("no TF instance found")
log.Error(err, "no terraform")
return nil, err
}
plan, err := r.tf.ShowPlanFile(ctx, req.Filename)
if err != nil {
log.Error(err, "unable to get the json plan output")
return nil, err
}
jsonBytes, err := json.Marshal(plan)
if err != nil {
log.Error(err, "unable to marshal the plan to json")
return nil, err
}
return &ShowPlanFileReply{JsonOutput: jsonBytes}, nil
} | Class | 2 |
func (r *TerraformRunnerServer) Output(ctx context.Context, req *OutputRequest) (*OutputReply, error) {
log := ctrl.LoggerFrom(ctx, "instance-id", r.InstanceID).WithName(loggerName)
log.Info("creating outputs")
if req.TfInstance != r.InstanceID {
err := fmt.Errorf("no TF instance found")
log.Error(err, "no terraform")
return nil, err
}
outputs, err := r.tf.Output(ctx)
if err != nil {
log.Error(err, "unable to get outputs")
return nil, err
}
outputReply := &OutputReply{Outputs: map[string]*OutputMeta{}}
for k, v := range outputs {
outputReply.Outputs[k] = &OutputMeta{
Sensitive: v.Sensitive,
Type: v.Type,
Value: v.Value,
}
}
return outputReply, nil
} | Class | 2 |
func (ctx *Context) RedirectToFirst(location ...string) {
for _, loc := range location {
if len(loc) == 0 {
continue
}
// Unfortunately browsers consider a redirect Location with preceding "//" and "/\" as meaning redirect to "http(s)://REST_OF_PATH"
// Therefore we should ignore these redirect locations to prevent open redirects
if len(loc) > 1 && loc[0] == '/' && (loc[1] == '/' || loc[1] == '\\') {
continue
}
u, err := url.Parse(loc)
if err != nil || ((u.Scheme != "" || u.Host != "") && !strings.HasPrefix(strings.ToLower(loc), strings.ToLower(setting.AppURL))) {
continue
}
ctx.Redirect(loc)
return
}
ctx.Redirect(setting.AppSubURL + "/")
} | Base | 1 |
func (t *assetAction) checkERC20Deposit() error {
asset, _ := t.asset.ERC20()
return t.bridgeView.FindDeposit(
t.erc20D, t.blockHeight, t.logIndex, asset.Address(),
)
} | Class | 2 |
func (t *assetAction) checkERC20BridgeResumed() error {
return t.bridgeView.FindBridgeResumed(
t.erc20BridgeResumed, t.blockHeight, t.logIndex)
} | Class | 2 |
func (t *assetAction) checkERC20AssetList() error {
return t.bridgeView.FindAssetList(t.erc20AL, t.blockHeight, t.logIndex)
} | Class | 2 |
func (t *assetAction) checkERC20BridgeStopped() error {
return t.bridgeView.FindBridgeStopped(
t.erc20BridgeStopped, t.blockHeight, t.logIndex)
} | Class | 2 |
func (t *assetAction) checkERC20AssetLimitsUpdated() error {
asset, _ := t.asset.ERC20()
return t.bridgeView.FindAssetLimitsUpdated(
t.erc20AssetLimitsUpdated, t.blockHeight, t.logIndex, asset.Address(),
)
} | Class | 2 |
func (m *MockERC20BridgeView) FindBridgeResumed(arg0 *types.ERC20EventBridgeResumed, arg1, arg2 uint64) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "FindBridgeResumed", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
} | Class | 2 |
func (m *MockERC20BridgeView) FindDeposit(arg0 *types.ERC20Deposit, arg1, arg2 uint64, arg3 string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "FindDeposit", arg0, arg1, arg2, arg3)
ret0, _ := ret[0].(error)
return ret0
} | Class | 2 |
func (mr *MockERC20BridgeViewMockRecorder) FindAssetList(arg0, arg1, arg2 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindAssetList", reflect.TypeOf((*MockERC20BridgeView)(nil).FindAssetList), arg0, arg1, arg2)
} | Class | 2 |
func (m *MockERC20BridgeView) FindBridgeStopped(arg0 *types.ERC20EventBridgeStopped, arg1, arg2 uint64) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "FindBridgeStopped", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
} | Class | 2 |
func (mr *MockERC20BridgeViewMockRecorder) FindDeposit(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindDeposit", reflect.TypeOf((*MockERC20BridgeView)(nil).FindDeposit), arg0, arg1, arg2, arg3)
} | Class | 2 |
func (m *MockERC20BridgeView) FindAssetList(arg0 *types.ERC20AssetList, arg1, arg2 uint64) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "FindAssetList", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
return ret0
} | Class | 2 |
func (mr *MockERC20BridgeViewMockRecorder) FindBridgeResumed(arg0, arg1, arg2 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindBridgeResumed", reflect.TypeOf((*MockERC20BridgeView)(nil).FindBridgeResumed), arg0, arg1, arg2)
} | Class | 2 |
func (mr *MockERC20BridgeViewMockRecorder) FindAssetLimitsUpdated(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindAssetLimitsUpdated", reflect.TypeOf((*MockERC20BridgeView)(nil).FindAssetLimitsUpdated), arg0, arg1, arg2, arg3)
} | Class | 2 |
func (m *MockERC20BridgeView) FindAssetLimitsUpdated(arg0 *types.ERC20AssetLimitsUpdated, arg1, arg2 uint64, arg3 string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "FindAssetLimitsUpdated", arg0, arg1, arg2, arg3)
ret0, _ := ret[0].(error)
return ret0
} | Class | 2 |
func (mr *MockERC20BridgeViewMockRecorder) FindBridgeStopped(arg0, arg1, arg2 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindBridgeStopped", reflect.TypeOf((*MockERC20BridgeView)(nil).FindBridgeStopped), arg0, arg1, arg2)
} | Class | 2 |
func (e *ERC20LogicView) FindBridgeStopped(
al *types.ERC20EventBridgeStopped,
blockNumber,
logIndex uint64,
) error {
bf, err := bridgecontract.NewErc20BridgeLogicRestrictedFilterer(
e.clt.CollateralBridgeAddress(), e.clt)
if err != nil {
return err
}
resp := "ok"
defer func() {
metrics.EthCallInc("find_bridge_stopped", resp)
}()
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
iter, err := bf.FilterBridgeStopped(
&bind.FilterOpts{
Start: blockNumber - 1,
Context: ctx,
},
)
if err != nil {
resp = getMaybeHTTPStatus(err)
return err
}
defer iter.Close()
var event *bridgecontract.Erc20BridgeLogicRestrictedBridgeStopped
for iter.Next() {
if iter.Event.Raw.BlockNumber == blockNumber &&
uint64(iter.Event.Raw.Index) == logIndex {
event = iter.Event
break
}
}
if event == nil {
return ErrUnableToFindERC20BridgeStopped
}
// now ensure we have enough confirmations
if err := e.ethConfs.Check(event.Raw.BlockNumber); err != nil {
return err
}
return nil
} | Class | 2 |
func (e *ERC20LogicView) FindAssetList(
al *types.ERC20AssetList,
blockNumber,
logIndex uint64,
) error {
bf, err := bridgecontract.NewErc20BridgeLogicRestrictedFilterer(
e.clt.CollateralBridgeAddress(), e.clt)
if err != nil {
return err
}
resp := "ok"
defer func() {
metrics.EthCallInc("find_asset_list", al.VegaAssetID, resp)
}()
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
iter, err := bf.FilterAssetListed(
&bind.FilterOpts{
Start: blockNumber - 1,
Context: ctx,
},
[]ethcommon.Address{ethcommon.HexToAddress(al.AssetSource)},
[][32]byte{},
)
if err != nil {
resp = getMaybeHTTPStatus(err)
return err
}
defer iter.Close()
var event *bridgecontract.Erc20BridgeLogicRestrictedAssetListed
assetID := strings.TrimPrefix(al.VegaAssetID, "0x")
for iter.Next() {
if hex.EncodeToString(iter.Event.VegaAssetId[:]) == assetID &&
iter.Event.Raw.BlockNumber == blockNumber &&
uint64(iter.Event.Raw.Index) == logIndex {
event = iter.Event
break
}
}
if event == nil {
return ErrUnableToFindERC20AssetList
}
// now ensure we have enough confirmations
if err := e.ethConfs.Check(event.Raw.BlockNumber); err != nil {
return err
}
return nil
} | Class | 2 |
func (e *ERC20LogicView) FindAssetLimitsUpdated(
update *types.ERC20AssetLimitsUpdated,
blockNumber uint64, logIndex uint64,
ethAssetAddress string,
) error {
bf, err := bridgecontract.NewErc20BridgeLogicRestrictedFilterer(
e.clt.CollateralBridgeAddress(), e.clt)
if err != nil {
return err
}
resp := "ok"
defer func() {
metrics.EthCallInc("find_asset_limits_updated", update.VegaAssetID, resp)
}()
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
iter, err := bf.FilterAssetLimitsUpdated(
&bind.FilterOpts{
Start: blockNumber - 1,
Context: ctx,
},
[]ethcommon.Address{ethcommon.HexToAddress(ethAssetAddress)},
)
if err != nil {
resp = getMaybeHTTPStatus(err)
return err
}
defer iter.Close()
var event *bridgecontract.Erc20BridgeLogicRestrictedAssetLimitsUpdated
for iter.Next() {
eventLifetimeLimit, _ := num.UintFromBig(iter.Event.LifetimeLimit)
eventWithdrawThreshold, _ := num.UintFromBig(iter.Event.WithdrawThreshold)
if update.LifetimeLimits.EQ(eventLifetimeLimit) &&
update.WithdrawThreshold.EQ(eventWithdrawThreshold) &&
iter.Event.Raw.BlockNumber == blockNumber &&
uint64(iter.Event.Raw.Index) == logIndex {
event = iter.Event
break
}
}
if event == nil {
return ErrUnableToFindERC20AssetLimitsUpdated
}
// now ensure we have enough confirmations
if err := e.ethConfs.Check(event.Raw.BlockNumber); err != nil {
return err
}
return nil
} | Class | 2 |
func (e *ERC20LogicView) FindWithdrawal(
w *types.ERC20Withdrawal,
blockNumber, logIndex uint64,
ethAssetAddress string,
) (*big.Int, string, uint, error) {
bf, err := bridgecontract.NewErc20BridgeLogicRestrictedFilterer(
e.clt.CollateralBridgeAddress(), e.clt)
if err != nil {
return nil, "", 0, err
}
resp := "ok"
defer func() {
metrics.EthCallInc("find_withdrawal", w.VegaAssetID, resp)
}()
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
iter, err := bf.FilterAssetWithdrawn(
&bind.FilterOpts{
Start: blockNumber - 1,
Context: ctx,
},
// user_address
[]ethcommon.Address{ethcommon.HexToAddress(w.TargetEthereumAddress)},
// asset_source
[]ethcommon.Address{ethcommon.HexToAddress(ethAssetAddress)})
if err != nil {
resp = getMaybeHTTPStatus(err)
return nil, "", 0, err
}
defer iter.Close()
var event *bridgecontract.Erc20BridgeLogicRestrictedAssetWithdrawn
nonce := &big.Int{}
_, ok := nonce.SetString(w.ReferenceNonce, 10)
if !ok {
return nil, "", 0, fmt.Errorf("could not use reference nonce, expected base 10 integer: %v", w.ReferenceNonce)
}
for iter.Next() {
if nonce.Cmp(iter.Event.Nonce) == 0 &&
iter.Event.Raw.BlockNumber == blockNumber &&
uint64(iter.Event.Raw.Index) == logIndex {
event = iter.Event
break
}
}
if event == nil {
return nil, "", 0, ErrUnableToFindERC20Withdrawal
}
// now ensure we have enough confirmations
if err := e.ethConfs.Check(event.Raw.BlockNumber); err != nil {
return nil, "", 0, err
}
return nonce, event.Raw.TxHash.Hex(), event.Raw.Index, nil
} | Class | 2 |
func (e *ERC20LogicView) FindBridgeResumed(
al *types.ERC20EventBridgeResumed,
blockNumber,
logIndex uint64,
) error {
bf, err := bridgecontract.NewErc20BridgeLogicRestrictedFilterer(
e.clt.CollateralBridgeAddress(), e.clt)
if err != nil {
return err
}
resp := "ok"
defer func() {
metrics.EthCallInc("find_bridge_stopped", resp)
}()
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
iter, err := bf.FilterBridgeResumed(
&bind.FilterOpts{
Start: blockNumber - 1,
Context: ctx,
},
)
if err != nil {
resp = getMaybeHTTPStatus(err)
return err
}
defer iter.Close()
var event *bridgecontract.Erc20BridgeLogicRestrictedBridgeResumed
for iter.Next() {
if iter.Event.Raw.BlockNumber == blockNumber &&
uint64(iter.Event.Raw.Index) == logIndex {
event = iter.Event
break
}
}
if event == nil {
return ErrUnableToFindERC20BridgeStopped
}
// now ensure we have enough confirmations
if err := e.ethConfs.Check(event.Raw.BlockNumber); err != nil {
return err
}
return nil
} | Class | 2 |
func (e *ERC20LogicView) FindDeposit(
d *types.ERC20Deposit,
blockNumber, logIndex uint64,
ethAssetAddress string,
) error {
bf, err := bridgecontract.NewErc20BridgeLogicRestrictedFilterer(
e.clt.CollateralBridgeAddress(), e.clt)
if err != nil {
return err
}
resp := "ok"
defer func() {
metrics.EthCallInc("find_deposit", d.VegaAssetID, resp)
}()
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
iter, err := bf.FilterAssetDeposited(
&bind.FilterOpts{
Start: blockNumber - 1,
Context: ctx,
},
// user_address
[]ethcommon.Address{ethcommon.HexToAddress(d.SourceEthereumAddress)},
// asset_source
[]ethcommon.Address{ethcommon.HexToAddress(ethAssetAddress)})
if err != nil {
resp = getMaybeHTTPStatus(err)
return err
}
defer iter.Close()
depamount := d.Amount.BigInt()
var event *bridgecontract.Erc20BridgeLogicRestrictedAssetDeposited
targetPartyID := strings.TrimPrefix(d.TargetPartyID, "0x")
for iter.Next() {
if hex.EncodeToString(iter.Event.VegaPublicKey[:]) == targetPartyID &&
iter.Event.Amount.Cmp(depamount) == 0 &&
iter.Event.Raw.BlockNumber == blockNumber &&
uint64(iter.Event.Raw.Index) == logIndex {
event = iter.Event
break
}
}
if event == nil {
return ErrUnableToFindERC20Deposit
}
// now ensure we have enough confirmations
if err := e.ethConfs.Check(event.Raw.BlockNumber); err != nil {
return err
}
return nil
} | Class | 2 |
func (*BridgeViewStub) FindDeposit(d *types.ERC20Deposit, blockNumber, logIndex uint64, ethAssetAddress string) error {
return nil
} | Class | 2 |
func (*BridgeViewStub) FindBridgeResumed(al *types.ERC20EventBridgeResumed, blockNumber, logIndex uint64) error {
return nil
} | Class | 2 |
func (*BridgeViewStub) FindBridgeStopped(al *types.ERC20EventBridgeStopped, blockNumber, logIndex uint64) error {
return nil
} | Class | 2 |
func (*BridgeViewStub) FindAssetLimitsUpdated(w *types.ERC20AssetLimitsUpdated, blockNumber, logIndex uint64, ethAssetAddress string) error {
return nil
} | Class | 2 |
func (*BridgeViewStub) FindAssetList(al *types.ERC20AssetList, blockNumber, logIndex uint64) error {
return nil
} | Class | 2 |
func (o *OnChainVerifier) filterSignerAdded(
ctx context.Context,
filterer *multisig.MultisigControlFilterer,
event *types.SignerEvent,
) error {
iter, err := filterer.FilterSignerAdded(
&bind.FilterOpts{
Start: event.BlockNumber,
End: &event.BlockNumber,
Context: ctx,
},
)
if err != nil {
o.log.Error("Couldn't start filtering on signer added event",
logging.Error(err))
return err
}
defer iter.Close()
for iter.Next() {
if o.log.GetLevel() <= logging.DebugLevel {
o.log.Debug("found signer added event on chain",
logging.String("new-signer", iter.Event.NewSigner.Hex()),
)
}
nonce, _ := big.NewInt(0).SetString(event.Nonce, 10)
if iter.Event.Raw.BlockNumber == event.BlockNumber &&
uint64(iter.Event.Raw.Index) == event.LogIndex &&
iter.Event.NewSigner.Hex() == event.Address &&
nonce.Cmp(iter.Event.Nonce) == 0 {
// now we know the event is OK,
// just need to check for confirmations
return o.ethConfirmations.Check(event.BlockNumber)
}
}
return ErrNoSignerEventFound
} | Class | 2 |
func (o *OnChainVerifier) CheckThresholdSetEvent(
event *types.SignerThresholdSetEvent,
) error {
o.mu.RLock()
defer o.mu.RUnlock()
if o.log.GetLevel() <= logging.DebugLevel {
o.log.Debug("checking threshold set event on chain",
logging.String("contract-address", o.multiSigAddress.Hex()),
logging.String("event", event.String()),
)
}
filterer, err := multisig.NewMultisigControlFilterer(
o.multiSigAddress,
o.ethClient,
)
if err != nil {
o.log.Error("could not instantiate multisig control filterer",
logging.Error(err))
return err
}
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
iter, err := filterer.FilterThresholdSet(
&bind.FilterOpts{
Start: event.BlockNumber,
End: &event.BlockNumber,
Context: ctx,
},
)
if err != nil {
o.log.Error("Couldn't start filtering on signer added event",
logging.Error(err))
return err
}
defer iter.Close()
for iter.Next() {
if o.log.GetLevel() <= logging.DebugLevel {
o.log.Debug("found threshold set event on chain",
logging.Uint16("new-threshold", iter.Event.NewThreshold),
)
}
nonce, _ := big.NewInt(0).SetString(event.Nonce, 10)
if iter.Event.Raw.BlockNumber == event.BlockNumber &&
uint64(iter.Event.Raw.Index) == event.LogIndex &&
iter.Event.NewThreshold == uint16(event.Threshold) &&
nonce.Cmp(iter.Event.Nonce) == 0 {
// now we know the event is OK,
// just need to check for confirmations
return o.ethConfirmations.Check(event.BlockNumber)
}
}
return ErrNoThresholdSetEventFound
} | Class | 2 |
func (o *OnChainVerifier) filterSignerRemoved(
ctx context.Context,
filterer *multisig.MultisigControlFilterer,
event *types.SignerEvent,
) error {
iter, err := filterer.FilterSignerRemoved(
&bind.FilterOpts{
Start: event.BlockNumber,
End: &event.BlockNumber,
Context: ctx,
},
)
if err != nil {
o.log.Error("Couldn't start filtering on signer removed event",
logging.Error(err))
return err
}
defer iter.Close()
for iter.Next() {
if o.log.GetLevel() <= logging.DebugLevel {
o.log.Debug("found signer removed event on chain",
logging.String("old-signer", iter.Event.OldSigner.Hex()),
)
}
nonce, _ := big.NewInt(0).SetString(event.Nonce, 10)
if iter.Event.Raw.BlockNumber == event.BlockNumber &&
uint64(iter.Event.Raw.Index) == event.LogIndex &&
iter.Event.OldSigner.Hex() == event.Address &&
nonce.Cmp(iter.Event.Nonce) == 0 {
// now we know the event is OK,
// just need to check for confirmations
return o.ethConfirmations.Check(event.BlockNumber)
}
}
return ErrNoSignerEventFound
} | Class | 2 |
func ValidateAllAuthorizationModels(ctx context.Context, db storage.OpenFGADatastore) ([]validationResult, error) {
validationResults := make([]validationResult, 0)
continuationTokenStores := ""
for {
// fetch a page of stores
stores, tokenStores, err := db.ListStores(ctx, storage.PaginationOptions{
PageSize: 100,
From: continuationTokenStores,
})
if err != nil {
return nil, fmt.Errorf("error reading stores: %w", err)
}
// validate each store
for _, store := range stores {
latestModelID, err := db.FindLatestAuthorizationModelID(ctx, store.Id)
if err != nil {
fmt.Printf("no models in store %s \n", store.Id)
}
continuationTokenModels := ""
for {
// fetch a page of models for that store
models, tokenModels, err := db.ReadAuthorizationModels(ctx, store.Id, storage.PaginationOptions{
PageSize: 100,
From: continuationTokenModels,
})
if err != nil {
return nil, fmt.Errorf("error reading authorization models: %w", err)
}
// validate each model
for _, model := range models {
_, err := typesystem.NewAndValidate(model)
validationResult := validationResult{
StoreID: store.Id,
ModelID: model.Id,
IsLatestModel: model.Id == latestModelID,
}
if err != nil {
validationResult.Error = err.Error()
}
validationResults = append(validationResults, validationResult)
}
continuationTokenModels = string(tokenModels)
if continuationTokenModels == "" {
break
}
}
}
// next page of stores
continuationTokenStores = string(tokenStores)
if continuationTokenStores == "" {
break
}
}
return validationResults, nil
} | Base | 1 |
func (q *ExpandQuery) Execute(ctx context.Context, req *openfgapb.ExpandRequest) (*openfgapb.ExpandResponse, error) {
store := req.GetStoreId()
modelID := req.GetAuthorizationModelId()
tupleKey := req.GetTupleKey()
object := tupleKey.GetObject()
relation := tupleKey.GetRelation()
if object == "" || relation == "" {
return nil, serverErrors.InvalidExpandInput
}
tk := tupleUtils.NewTupleKey(object, relation, "")
model, err := q.datastore.ReadAuthorizationModel(ctx, store, modelID)
if err != nil {
if errors.Is(err, storage.ErrNotFound) {
return nil, serverErrors.AuthorizationModelNotFound(modelID)
}
return nil, serverErrors.HandleError("", err)
}
if !typesystem.IsSchemaVersionSupported(model.GetSchemaVersion()) {
return nil, serverErrors.ValidationError(typesystem.ErrInvalidSchemaVersion)
}
typesys := typesystem.New(model)
if err = validation.ValidateObject(typesys, tk); err != nil {
return nil, serverErrors.ValidationError(err)
}
err = validation.ValidateRelation(typesys, tk)
if err != nil {
return nil, serverErrors.ValidationError(err)
}
objectType := tupleUtils.GetType(object)
rel, err := typesys.GetRelation(objectType, relation)
if err != nil {
if errors.Is(err, typesystem.ErrObjectTypeUndefined) {
return nil, serverErrors.TypeNotFound(objectType)
}
if errors.Is(err, typesystem.ErrRelationUndefined) {
return nil, serverErrors.RelationNotFound(relation, objectType, tk)
}
return nil, serverErrors.HandleError("", err)
}
userset := rel.GetRewrite()
root, err := q.resolveUserset(ctx, store, userset, tk, typesys)
if err != nil {
return nil, err
}
return &openfgapb.ExpandResponse{
Tree: &openfgapb.UsersetTree{
Root: root,
},
}, nil
} | Base | 1 |
func (w *WriteAuthorizationModelCommand) Execute(ctx context.Context, req *openfgapb.WriteAuthorizationModelRequest) (*openfgapb.WriteAuthorizationModelResponse, error) {
// Until this is solved: https://github.com/envoyproxy/protoc-gen-validate/issues/74
if len(req.GetTypeDefinitions()) > w.backend.MaxTypesPerAuthorizationModel() {
return nil, serverErrors.ExceededEntityLimit("type definitions in an authorization model", w.backend.MaxTypesPerAuthorizationModel())
}
// Fill in the schema version for old requests, which don't contain it, while we migrate to the new schema version.
if req.SchemaVersion == "" {
req.SchemaVersion = typesystem.SchemaVersion1_1
}
model := &openfgapb.AuthorizationModel{
Id: ulid.Make().String(),
SchemaVersion: req.GetSchemaVersion(),
TypeDefinitions: req.GetTypeDefinitions(),
}
_, err := typesystem.NewAndValidate(model)
if err != nil {
return nil, serverErrors.InvalidAuthorizationModelInput(err)
}
err = w.backend.WriteAuthorizationModel(ctx, req.GetStoreId(), model)
if err != nil {
return nil, serverErrors.NewInternalError("Error writing authorization model configuration", err)
}
return &openfgapb.WriteAuthorizationModelResponse{
AuthorizationModelId: model.Id,
}, nil
} | Base | 1 |
func (s *Server) StreamedListObjects(req *openfgapb.StreamedListObjectsRequest, srv openfgapb.OpenFGAService_StreamedListObjectsServer) error {
ctx := srv.Context()
ctx, span := tracer.Start(ctx, "StreamedListObjects", trace.WithAttributes(
attribute.String("object_type", req.GetType()),
attribute.String("relation", req.GetRelation()),
attribute.String("user", req.GetUser()),
))
defer span.End()
storeID := req.GetStoreId()
modelID, err := s.resolveAuthorizationModelID(ctx, storeID, req.GetAuthorizationModelId())
if err != nil {
return err
}
model, err := s.datastore.ReadAuthorizationModel(ctx, storeID, modelID)
if err != nil {
if errors.Is(err, storage.ErrNotFound) {
return serverErrors.AuthorizationModelNotFound(req.GetAuthorizationModelId())
}
return serverErrors.HandleError("", err)
}
typesys := typesystem.New(model)
ctx = typesystem.ContextWithTypesystem(ctx, typesys)
q := &commands.ListObjectsQuery{
Datastore: s.datastore,
Logger: s.logger,
ListObjectsDeadline: s.config.ListObjectsDeadline,
ListObjectsMaxResults: s.config.ListObjectsMaxResults,
ResolveNodeLimit: s.config.ResolveNodeLimit,
}
req.AuthorizationModelId = modelID
return q.ExecuteStreamed(ctx, req, srv)
} | Base | 1 |
func (s *Server) ListObjects(ctx context.Context, req *openfgapb.ListObjectsRequest) (*openfgapb.ListObjectsResponse, error) {
storeID := req.GetStoreId()
targetObjectType := req.GetType()
ctx, span := tracer.Start(ctx, "ListObjects", trace.WithAttributes(
attribute.String("object_type", targetObjectType),
attribute.String("relation", req.GetRelation()),
attribute.String("user", req.GetUser()),
))
defer span.End()
modelID := req.GetAuthorizationModelId()
modelID, err := s.resolveAuthorizationModelID(ctx, storeID, modelID)
if err != nil {
return nil, err
}
model, err := s.datastore.ReadAuthorizationModel(ctx, storeID, modelID)
if err != nil {
if errors.Is(err, storage.ErrNotFound) {
return nil, serverErrors.AuthorizationModelNotFound(modelID)
}
return nil, err
}
typesys := typesystem.New(model)
ctx = typesystem.ContextWithTypesystem(ctx, typesys)
q := &commands.ListObjectsQuery{
Datastore: s.datastore,
Logger: s.logger,
ListObjectsDeadline: s.config.ListObjectsDeadline,
ListObjectsMaxResults: s.config.ListObjectsMaxResults,
ResolveNodeLimit: s.config.ResolveNodeLimit,
}
return q.Execute(ctx, &openfgapb.ListObjectsRequest{
StoreId: storeID,
ContextualTuples: req.GetContextualTuples(),
AuthorizationModelId: modelID,
Type: targetObjectType,
Relation: req.Relation,
User: req.User,
})
} | Base | 1 |
func TestCheckDoesNotThrowBecauseDirectTupleWasFound(t *testing.T) {
ctx := context.Background()
storeID := ulid.Make().String()
modelID := ulid.Make().String()
typedefs := parser.MustParse(`
type user
type repo
relations
define reader: [user] as self
`)
tk := tuple.NewTupleKey("repo:openfga", "reader", "user:anne")
tuple := &openfgapb.Tuple{Key: tk}
mockController := gomock.NewController(t)
defer mockController.Finish()
mockDatastore := mockstorage.NewMockOpenFGADatastore(mockController)
mockDatastore.EXPECT().
ReadAuthorizationModel(gomock.Any(), storeID, modelID).
AnyTimes().
Return(&openfgapb.AuthorizationModel{
SchemaVersion: typesystem.SchemaVersion1_1,
TypeDefinitions: typedefs,
}, nil)
// it could happen that one of the following two mocks won't be necessary because the goroutine will be short-circuited
mockDatastore.EXPECT().
ReadUserTuple(gomock.Any(), storeID, gomock.Any()).
AnyTimes().
Return(tuple, nil)
mockDatastore.EXPECT().
ReadUsersetTuples(gomock.Any(), storeID, gomock.Any()).
AnyTimes().
DoAndReturn(
func(_ context.Context, _ string, _ storage.ReadUsersetTuplesFilter) (storage.TupleIterator, error) {
time.Sleep(50 * time.Millisecond)
return nil, errors.New("some error")
})
s := New(&Dependencies{
Datastore: mockDatastore,
Logger: logger.NewNoopLogger(),
Transport: gateway.NewNoopTransport(),
}, &Config{
ResolveNodeLimit: 25,
})
checkResponse, err := s.Check(ctx, &openfgapb.CheckRequest{
StoreId: storeID,
TupleKey: tk,
AuthorizationModelId: modelID,
})
require.NoError(t, err)
require.Equal(t, true, checkResponse.Allowed)
} | Base | 1 |
func BenchmarkListObjectsNoRaceCondition(b *testing.B) {
ctx := context.Background()
logger := logger.NewNoopLogger()
transport := gateway.NewNoopTransport()
store := ulid.Make().String()
modelID := ulid.Make().String()
mockController := gomock.NewController(b)
defer mockController.Finish()
typedefs := parser.MustParse(`
type user
type repo
relations
define allowed: [user] as self
define viewer: [user] as self and allowed
`)
mockDatastore := mockstorage.NewMockOpenFGADatastore(mockController)
mockDatastore.EXPECT().ReadAuthorizationModel(gomock.Any(), store, modelID).AnyTimes().Return(&openfgapb.AuthorizationModel{
SchemaVersion: typesystem.SchemaVersion1_1,
TypeDefinitions: typedefs,
}, nil)
mockDatastore.EXPECT().ListObjectsByType(gomock.Any(), store, "repo").AnyTimes().Return(nil, errors.New("error reading from storage"))
s := New(&Dependencies{
Datastore: mockDatastore,
Transport: transport,
Logger: logger,
}, &Config{
ResolveNodeLimit: 25,
ListObjectsDeadline: 5 * time.Second,
ListObjectsMaxResults: 1000,
})
b.ResetTimer()
for i := 0; i < b.N; i++ {
_, err := s.ListObjects(ctx, &openfgapb.ListObjectsRequest{
StoreId: store,
AuthorizationModelId: modelID,
Type: "repo",
Relation: "viewer",
User: "user:bob",
})
require.ErrorIs(b, err, serverErrors.NewInternalError("", errors.New("error reading from storage")))
err = s.StreamedListObjects(&openfgapb.StreamedListObjectsRequest{
StoreId: store,
AuthorizationModelId: modelID,
Type: "repo",
Relation: "viewer",
User: "user:bob",
}, NewMockStreamServer())
require.ErrorIs(b, err, serverErrors.NewInternalError("", errors.New("error reading from storage")))
}
} | Base | 1 |
func TestListObjects_Unoptimized_UnhappyPaths(t *testing.T) {
ctx := context.Background()
logger := logger.NewNoopLogger()
transport := gateway.NewNoopTransport()
store := ulid.Make().String()
modelID := ulid.Make().String()
mockController := gomock.NewController(t)
defer mockController.Finish()
mockDatastore := mockstorage.NewMockOpenFGADatastore(mockController)
mockDatastore.EXPECT().ReadAuthorizationModel(gomock.Any(), store, modelID).AnyTimes().Return(&openfgapb.AuthorizationModel{
SchemaVersion: typesystem.SchemaVersion1_1,
TypeDefinitions: parser.MustParse(`
type user
type repo
relations
define allowed: [user] as self
define viewer: [user] as self and allowed
`),
}, nil)
mockDatastore.EXPECT().ListObjectsByType(gomock.Any(), store, "repo").AnyTimes().Return(nil, errors.New("error reading from storage"))
s := New(&Dependencies{
Datastore: mockDatastore,
Transport: transport,
Logger: logger,
}, &Config{
ResolveNodeLimit: 25,
ListObjectsDeadline: 5 * time.Second,
ListObjectsMaxResults: 1000,
})
t.Run("error_listing_objects_from_storage_in_non-streaming_version", func(t *testing.T) {
res, err := s.ListObjects(ctx, &openfgapb.ListObjectsRequest{
StoreId: store,
AuthorizationModelId: modelID,
Type: "repo",
Relation: "viewer",
User: "user:bob",
})
require.Nil(t, res)
require.ErrorIs(t, err, serverErrors.NewInternalError("", errors.New("error reading from storage")))
})
t.Run("error_listing_objects_from_storage_in_streaming_version", func(t *testing.T) {
err := s.StreamedListObjects(&openfgapb.StreamedListObjectsRequest{
StoreId: store,
AuthorizationModelId: modelID,
Type: "repo",
Relation: "viewer",
User: "user:bob",
}, NewMockStreamServer())
require.ErrorIs(t, err, serverErrors.NewInternalError("", errors.New("error reading from storage")))
})
} | Base | 1 |
func BenchmarkListObjectsWithConcurrentChecks(b *testing.B, ds storage.OpenFGADatastore) {
ctx := context.Background()
store := ulid.Make().String()
typedefs := parser.MustParse(`
type user
type document
relations
define allowed: [user] as self
define viewer: [user] as self and allowed
`)
model := &openfgapb.AuthorizationModel{
Id: ulid.Make().String(),
SchemaVersion: typesystem.SchemaVersion1_1,
TypeDefinitions: typedefs,
}
err := ds.WriteAuthorizationModel(ctx, store, model)
require.NoError(b, err)
n := 0
for i := 0; i < 100; i++ {
var tuples []*openfgapb.TupleKey
for j := 0; j < ds.MaxTuplesPerWrite()/2; j++ {
obj := fmt.Sprintf("document:%s", strconv.Itoa(n))
user := fmt.Sprintf("user:%s", strconv.Itoa(n))
tuples = append(
tuples,
tuple.NewTupleKey(obj, "viewer", user),
tuple.NewTupleKey(obj, "allowed", user),
)
n += 1
}
err = ds.Write(ctx, store, nil, tuples)
require.NoError(b, err)
}
listObjectsQuery := commands.ListObjectsQuery{
Datastore: ds,
Logger: logger.NewNoopLogger(),
ResolveNodeLimit: defaultResolveNodeLimit,
}
var r *openfgapb.ListObjectsResponse
ctx = typesystem.ContextWithTypesystem(ctx, typesystem.New(model))
b.ResetTimer()
for i := 0; i < b.N; i++ {
r, _ = listObjectsQuery.Execute(ctx, &openfgapb.ListObjectsRequest{
StoreId: store,
AuthorizationModelId: model.Id,
Type: "document",
Relation: "viewer",
User: "user:999",
})
}
listObjectsResponse = r
} | Base | 1 |
func BenchmarkListObjectsWithReverseExpand(b *testing.B, ds storage.OpenFGADatastore) {
ctx := context.Background()
store := ulid.Make().String()
model := &openfgapb.AuthorizationModel{
Id: ulid.Make().String(),
SchemaVersion: typesystem.SchemaVersion1_1,
TypeDefinitions: []*openfgapb.TypeDefinition{
{
Type: "user",
},
{
Type: "document",
Relations: map[string]*openfgapb.Userset{
"viewer": typesystem.This(),
},
Metadata: &openfgapb.Metadata{
Relations: map[string]*openfgapb.RelationMetadata{
"viewer": {
DirectlyRelatedUserTypes: []*openfgapb.RelationReference{
typesystem.DirectRelationReference("user", ""),
},
},
},
},
},
},
}
err := ds.WriteAuthorizationModel(ctx, store, model)
require.NoError(b, err)
n := 0
for i := 0; i < 100; i++ {
var tuples []*openfgapb.TupleKey
for j := 0; j < ds.MaxTuplesPerWrite(); j++ {
obj := fmt.Sprintf("document:%s", strconv.Itoa(n))
user := fmt.Sprintf("user:%s", strconv.Itoa(n))
tuples = append(tuples, tuple.NewTupleKey(obj, "viewer", user))
n += 1
}
err = ds.Write(ctx, store, nil, tuples)
require.NoError(b, err)
}
listObjectsQuery := commands.ListObjectsQuery{
Datastore: ds,
Logger: logger.NewNoopLogger(),
ResolveNodeLimit: defaultResolveNodeLimit,
}
var r *openfgapb.ListObjectsResponse
ctx = typesystem.ContextWithTypesystem(ctx, typesystem.New(model))
b.ResetTimer()
for i := 0; i < b.N; i++ {
r, _ = listObjectsQuery.Execute(ctx, &openfgapb.ListObjectsRequest{
StoreId: store,
AuthorizationModelId: model.Id,
Type: "document",
Relation: "viewer",
User: "user:999",
})
}
listObjectsResponse = r
} | Base | 1 |
func RunQueryTests(t *testing.T, ds storage.OpenFGADatastore) {
t.Run("TestReadAuthorizationModelQueryErrors", func(t *testing.T) { TestReadAuthorizationModelQueryErrors(t, ds) })
t.Run("TestSuccessfulReadAuthorizationModelQuery", func(t *testing.T) { TestSuccessfulReadAuthorizationModelQuery(t, ds) })
t.Run("TestReadAuthorizationModel", func(t *testing.T) { ReadAuthorizationModelTest(t, ds) })
t.Run("TestExpandQuery", func(t *testing.T) { TestExpandQuery(t, ds) })
t.Run("TestExpandQueryErrors", func(t *testing.T) { TestExpandQueryErrors(t, ds) })
t.Run("TestGetStoreQuery", func(t *testing.T) { TestGetStoreQuery(t, ds) })
t.Run("TestGetStoreSucceeds", func(t *testing.T) { TestGetStoreSucceeds(t, ds) })
t.Run("TestListStores", func(t *testing.T) { TestListStores(t, ds) })
t.Run("TestReadAssertionQuery", func(t *testing.T) { TestReadAssertionQuery(t, ds) })
t.Run("TestReadQuerySuccess", func(t *testing.T) { ReadQuerySuccessTest(t, ds) })
t.Run("TestReadQueryError", func(t *testing.T) { ReadQueryErrorTest(t, ds) })
t.Run("TestReadAllTuples", func(t *testing.T) { ReadAllTuplesTest(t, ds) })
t.Run("TestReadAllTuplesInvalidContinuationToken", func(t *testing.T) { ReadAllTuplesInvalidContinuationTokenTest(t, ds) })
t.Run("TestReadAuthorizationModelsWithoutPaging",
func(t *testing.T) { TestReadAuthorizationModelsWithoutPaging(t, ds) },
)
t.Run("TestReadAuthorizationModelsWithPaging",
func(t *testing.T) { TestReadAuthorizationModelsWithPaging(t, ds) },
)
t.Run("TestReadAuthorizationModelsInvalidContinuationToken",
func(t *testing.T) { TestReadAuthorizationModelsInvalidContinuationToken(t, ds) },
)
t.Run("TestReadChanges", func(t *testing.T) { TestReadChanges(t, ds) })
t.Run("TestReadChangesReturnsSameContTokenWhenNoChanges",
func(t *testing.T) { TestReadChangesReturnsSameContTokenWhenNoChanges(t, ds) },
)
t.Run("TestListObjectsRespectsMaxResults", func(t *testing.T) { TestListObjectsRespectsMaxResults(t, ds) })
} | Base | 1 |
func New(model *openfgapb.AuthorizationModel) *TypeSystem {
tds := make(map[string]*openfgapb.TypeDefinition, len(model.GetTypeDefinitions()))
relations := make(map[string]map[string]*openfgapb.Relation, len(model.GetTypeDefinitions()))
for _, td := range model.GetTypeDefinitions() {
tds[td.GetType()] = td
tdRelations := make(map[string]*openfgapb.Relation, len(td.GetRelations()))
for relation, rewrite := range td.GetRelations() {
r := &openfgapb.Relation{
Name: relation,
Rewrite: rewrite,
TypeInfo: &openfgapb.RelationTypeInfo{},
}
if metadata, ok := td.GetMetadata().GetRelations()[relation]; ok {
r.TypeInfo.DirectlyRelatedUserTypes = metadata.GetDirectlyRelatedUserTypes()
}
tdRelations[relation] = r
}
relations[td.GetType()] = tdRelations
}
return &TypeSystem{
modelID: model.GetId(),
schemaVersion: model.GetSchemaVersion(),
typeDefinitions: tds,
relations: relations,
}
} | Base | 1 |
func TestSuccessfulRewriteValidations(t *testing.T) {
var tests = []struct {
name string
model *openfgapb.AuthorizationModel
}{
{
name: "empty_relations",
model: &openfgapb.AuthorizationModel{
SchemaVersion: SchemaVersion1_1,
TypeDefinitions: []*openfgapb.TypeDefinition{
{
Type: "repo",
},
},
},
},
{
name: "zero_length_relations_is_valid",
model: &openfgapb.AuthorizationModel{
SchemaVersion: SchemaVersion1_1,
TypeDefinitions: []*openfgapb.TypeDefinition{
{
Type: "repo",
Relations: map[string]*openfgapb.Userset{},
},
},
},
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
_, err := NewAndValidate(test.model)
require.NoError(t, err)
})
}
} | Base | 1 |
func (c *LocalChecker) checkComputedUserset(parentctx context.Context, req *ResolveCheckRequest, rewrite *openfgav1.Userset_ComputedUserset) CheckHandlerFunc {
return func(ctx context.Context) (*ResolveCheckResponse, error) {
ctx, span := tracer.Start(ctx, "checkComputedUserset")
defer span.End()
return c.dispatch(
ctx,
&ResolveCheckRequest{
StoreID: req.GetStoreID(),
AuthorizationModelID: req.GetAuthorizationModelID(),
TupleKey: tuple.NewTupleKey(
req.TupleKey.GetObject(),
rewrite.ComputedUserset.GetRelation(),
req.TupleKey.GetUser(),
),
ResolutionMetadata: &ResolutionMetadata{
Depth: req.GetResolutionMetadata().Depth - 1,
DatastoreQueryCount: req.GetResolutionMetadata().DatastoreQueryCount,
},
})(ctx)
}
} | Base | 1 |
func TestListObjects_Unoptimized_UnhappyPaths_Known_Error(t *testing.T) {
ctx := context.Background()
store := ulid.Make().String()
modelID := ulid.Make().String()
mockController := gomock.NewController(t)
defer mockController.Finish()
mockDatastore := mockstorage.NewMockOpenFGADatastore(mockController)
mockDatastore.EXPECT().ReadAuthorizationModel(gomock.Any(), store, modelID).AnyTimes().Return(&openfgav1.AuthorizationModel{
SchemaVersion: typesystem.SchemaVersion1_1,
TypeDefinitions: parser.MustParse(`
type user
type repo
relations
define allowed: [user] as self
define viewer: [user] as self and allowed
`),
}, nil)
mockDatastore.EXPECT().ReadStartingWithUser(gomock.Any(), store, gomock.Any()).AnyTimes().Return(nil, serverErrors.AuthorizationModelResolutionTooComplex)
s := MustNewServerWithOpts(
WithDatastore(mockDatastore),
)
t.Run("error_listing_objects_from_storage_in_non-streaming_version", func(t *testing.T) {
res, err := s.ListObjects(ctx, &openfgav1.ListObjectsRequest{
StoreId: store,
AuthorizationModelId: modelID,
Type: "repo",
Relation: "viewer",
User: "user:bob",
})
require.Nil(t, res)
require.ErrorIs(t, err, serverErrors.AuthorizationModelResolutionTooComplex)
})
t.Run("error_listing_objects_from_storage_in_streaming_version", func(t *testing.T) {
err := s.StreamedListObjects(&openfgav1.StreamedListObjectsRequest{
StoreId: store,
AuthorizationModelId: modelID,
Type: "repo",
Relation: "viewer",
User: "user:bob",
}, NewMockStreamServer())
require.ErrorIs(t, err, serverErrors.AuthorizationModelResolutionTooComplex)
})
} | Base | 1 |
func TestListObjects_Unoptimized_UnhappyPaths(t *testing.T) {
ctx := context.Background()
store := ulid.Make().String()
modelID := ulid.Make().String()
mockController := gomock.NewController(t)
defer mockController.Finish()
mockDatastore := mockstorage.NewMockOpenFGADatastore(mockController)
mockDatastore.EXPECT().ReadAuthorizationModel(gomock.Any(), store, modelID).AnyTimes().Return(&openfgav1.AuthorizationModel{
SchemaVersion: typesystem.SchemaVersion1_1,
TypeDefinitions: parser.MustParse(`
type user
type repo
relations
define allowed: [user] as self
define viewer: [user] as self and allowed
`),
}, nil)
mockDatastore.EXPECT().ReadStartingWithUser(gomock.Any(), store, gomock.Any()).AnyTimes().Return(nil, errors.New("error reading from storage"))
s := MustNewServerWithOpts(
WithDatastore(mockDatastore),
)
t.Run("error_listing_objects_from_storage_in_non-streaming_version", func(t *testing.T) {
res, err := s.ListObjects(ctx, &openfgav1.ListObjectsRequest{
StoreId: store,
AuthorizationModelId: modelID,
Type: "repo",
Relation: "viewer",
User: "user:bob",
})
require.Nil(t, res)
require.ErrorIs(t, err, serverErrors.NewInternalError("", errors.New("error reading from storage")))
})
t.Run("error_listing_objects_from_storage_in_streaming_version", func(t *testing.T) {
err := s.StreamedListObjects(&openfgav1.StreamedListObjectsRequest{
StoreId: store,
AuthorizationModelId: modelID,
Type: "repo",
Relation: "viewer",
User: "user:bob",
}, NewMockStreamServer())
require.ErrorIs(t, err, serverErrors.NewInternalError("", errors.New("error reading from storage")))
})
} | Base | 1 |
func PostSambaConnectionsCreate(c *gin.Context) {
connection := model.Connections{}
c.ShouldBindJSON(&connection)
if connection.Port == "" {
connection.Port = "445"
}
if connection.Username == "" || connection.Host == "" {
c.JSON(common_err.CLIENT_ERROR, model.Result{Success: common_err.CHARACTER_LIMIT, Message: common_err.GetMsg(common_err.CHARACTER_LIMIT)})
return
}
if ok, _ := regexp.MatchString(`^[\w@#*.]{4,30}$`, connection.Password); !ok {
c.JSON(common_err.CLIENT_ERROR, model.Result{Success: common_err.CHARACTER_LIMIT, Message: common_err.GetMsg(common_err.CHARACTER_LIMIT)})
return
} | Class | 2 |
func (s *connectionsStruct) MountSmaba(username, host, directory, port, mountPoint, password string) string {
str := command2.ExecResultStr("source " + config.AppInfo.ShellPath + "/helper.sh ;MountCIFS " + username + " " + host + " " + directory + " " + port + " " + mountPoint + " " + password)
return str
} | Class | 2 |
Skipper: func(c echo.Context) bool {
return c.RealIP() == "::1" || c.RealIP() == "127.0.0.1"
// return true
},
ParseTokenFunc: func(token string, c echo.Context) (interface{}, error) {
claims, code := jwt.Validate(token) // TODO - needs JWT validation
if code != common_err.SUCCESS {
return nil, echo.ErrUnauthorized
}
c.Request().Header.Set("user_id", strconv.Itoa(claims.ID))
return claims, nil
},
TokenLookupFuncs: []echo_middleware.ValuesExtractor{
func(c echo.Context) ([]string, error) {
return []string{c.Request().Header.Get(echo.HeaderAuthorization)}, nil
},
},
})) | Class | 2 |
func (r *Reader) readBytes(op string) []byte {
size := int(r.ReadLong())
if size < 0 {
r.ReportError("ReadString", "invalid "+op+" length")
return nil
}
if size == 0 {
return []byte{}
}
// The bytes are entirely in the buffer and of a reasonable size.
// Use the byte slab.
if r.head+size <= r.tail && size <= 1024 {
if cap(r.slab) < size {
r.slab = make([]byte, 1024)
}
dst := r.slab[:size]
r.slab = r.slab[size:]
copy(dst, r.buf[r.head:r.head+size])
r.head += size
return dst
}
buf := make([]byte, size)
r.Read(buf)
return buf
} | Class | 2 |
func OperateFirewallPort(oldPorts, newPorts []int) error {
client, err := firewall.NewFirewallClient()
if err != nil {
return err
}
for _, port := range newPorts {
if err := client.Port(fireClient.FireInfo{Port: strconv.Itoa(port), Protocol: "tcp", Strategy: "accept"}, "add"); err != nil {
return err
}
}
for _, port := range oldPorts {
if err := client.Port(fireClient.FireInfo{Port: strconv.Itoa(port), Protocol: "tcp", Strategy: "accept"}, "remove"); err != nil {
return err
}
}
return client.Reload()
} | Base | 1 |
func useAPIAuthentication(next fasthttp.RequestHandler) fasthttp.RequestHandler {
token := auth.GetAPIToken()
if token == "" {
return next
}
log.Info("enabled token authentication on http server")
return func(ctx *fasthttp.RequestCtx) {
v := ctx.Request.Header.Peek(authConsts.APITokenHeader)
if auth.ExcludedRoute(string(ctx.Request.URI().FullURI())) || string(v) == token {
ctx.Request.Header.Del(authConsts.APITokenHeader)
next(ctx)
} else {
ctx.Error("invalid api token", http.StatusUnauthorized)
}
}
} | Class | 2 |
func ExcludedRoute(route string) bool {
for _, r := range excludedRoutes {
if strings.Contains(route, r) {
return true
}
}
return false
} | Class | 2 |
func TestExcludedRoute(t *testing.T) {
t.Run("healthz route is excluded", func(t *testing.T) {
route := "v1.0/healthz"
excluded := ExcludedRoute(route)
assert.True(t, excluded)
})
t.Run("custom route is not excluded", func(t *testing.T) {
route := "v1.0/state"
excluded := ExcludedRoute(route)
assert.False(t, excluded)
})
} | Class | 2 |
func rawFileHandler(w http.ResponseWriter, r *http.Request, file *files.FileInfo) (int, error) {
fd, err := file.Fs.Open(file.Path)
if err != nil {
return http.StatusInternalServerError, err
}
defer fd.Close()
setContentDisposition(w, r, file)
w.Header().Set("Cache-Control", "private")
http.ServeContent(w, r, file.Name, file.ModTime, fd)
return 0, nil
} | Base | 1 |
func getTokenFromStorage(c *fiber.Ctx, token string, cfg Config, sessionManager *sessionManager, storageManager *storageManager) []byte {
if cfg.Session != nil {
return sessionManager.getRaw(c, token, dummyValue)
}
return storageManager.getRaw(token)
} | Class | 2 |
func getTokenFromStorage(c *fiber.Ctx, token string, cfg Config, sessionManager *sessionManager, storageManager *storageManager) []byte {
if cfg.Session != nil {
return sessionManager.getRaw(c, token, dummyValue)
}
return storageManager.getRaw(token)
} | Compound | 4 |
func getTokenFromStorage(c *fiber.Ctx, token string, cfg Config, sessionManager *sessionManager, storageManager *storageManager) []byte {
if cfg.Session != nil {
return sessionManager.getRaw(c, token, dummyValue)
}
return storageManager.getRaw(token)
} | Base | 1 |
func getTokenFromStorage(c *fiber.Ctx, token string, cfg Config, sessionManager *sessionManager, storageManager *storageManager) []byte {
if cfg.Session != nil {
return sessionManager.getRaw(c, token, dummyValue)
}
return storageManager.getRaw(token)
} | Base | 1 |
func CsrfFromCookie(param string) func(c *fiber.Ctx) (string, error) {
return func(c *fiber.Ctx) (string, error) {
token := c.Cookies(param)
if token == "" {
return "", errMissingCookie
}
return token, nil
}
} | Class | 2 |
func CsrfFromCookie(param string) func(c *fiber.Ctx) (string, error) {
return func(c *fiber.Ctx) (string, error) {
token := c.Cookies(param)
if token == "" {
return "", errMissingCookie
}
return token, nil
}
} | Compound | 4 |
func CsrfFromCookie(param string) func(c *fiber.Ctx) (string, error) {
return func(c *fiber.Ctx) (string, error) {
token := c.Cookies(param)
if token == "" {
return "", errMissingCookie
}
return token, nil
}
} | Base | 1 |
func CsrfFromCookie(param string) func(c *fiber.Ctx) (string, error) {
return func(c *fiber.Ctx) (string, error) {
token := c.Cookies(param)
if token == "" {
return "", errMissingCookie
}
return token, nil
}
} | Base | 1 |
func CsrfFromHeader(param string) func(c *fiber.Ctx) (string, error) {
return func(c *fiber.Ctx) (string, error) {
token := c.Get(param)
if token == "" {
return "", errMissingHeader
}
return token, nil
}
} | Class | 2 |
func CsrfFromHeader(param string) func(c *fiber.Ctx) (string, error) {
return func(c *fiber.Ctx) (string, error) {
token := c.Get(param)
if token == "" {
return "", errMissingHeader
}
return token, nil
}
} | Compound | 4 |
func CsrfFromHeader(param string) func(c *fiber.Ctx) (string, error) {
return func(c *fiber.Ctx) (string, error) {
token := c.Get(param)
if token == "" {
return "", errMissingHeader
}
return token, nil
}
} | Base | 1 |
func CsrfFromHeader(param string) func(c *fiber.Ctx) (string, error) {
return func(c *fiber.Ctx) (string, error) {
token := c.Get(param)
if token == "" {
return "", errMissingHeader
}
return token, nil
}
} | Base | 1 |
func CsrfFromParam(param string) func(c *fiber.Ctx) (string, error) {
return func(c *fiber.Ctx) (string, error) {
token := c.Params(param)
if token == "" {
return "", errMissingParam
}
return token, nil
}
} | Class | 2 |
func CsrfFromParam(param string) func(c *fiber.Ctx) (string, error) {
return func(c *fiber.Ctx) (string, error) {
token := c.Params(param)
if token == "" {
return "", errMissingParam
}
return token, nil
}
} | Compound | 4 |
func CsrfFromParam(param string) func(c *fiber.Ctx) (string, error) {
return func(c *fiber.Ctx) (string, error) {
token := c.Params(param)
if token == "" {
return "", errMissingParam
}
return token, nil
}
} | Base | 1 |
func CsrfFromParam(param string) func(c *fiber.Ctx) (string, error) {
return func(c *fiber.Ctx) (string, error) {
token := c.Params(param)
if token == "" {
return "", errMissingParam
}
return token, nil
}
} | Base | 1 |
func CsrfFromQuery(param string) func(c *fiber.Ctx) (string, error) {
return func(c *fiber.Ctx) (string, error) {
token := c.Query(param)
if token == "" {
return "", errMissingQuery
}
return token, nil
}
} | Class | 2 |
func CsrfFromQuery(param string) func(c *fiber.Ctx) (string, error) {
return func(c *fiber.Ctx) (string, error) {
token := c.Query(param)
if token == "" {
return "", errMissingQuery
}
return token, nil
}
} | Compound | 4 |
func CsrfFromQuery(param string) func(c *fiber.Ctx) (string, error) {
return func(c *fiber.Ctx) (string, error) {
token := c.Query(param)
if token == "" {
return "", errMissingQuery
}
return token, nil
}
} | Base | 1 |
func CsrfFromQuery(param string) func(c *fiber.Ctx) (string, error) {
return func(c *fiber.Ctx) (string, error) {
token := c.Query(param)
if token == "" {
return "", errMissingQuery
}
return token, nil
}
} | Base | 1 |
func CsrfFromForm(param string) func(c *fiber.Ctx) (string, error) {
return func(c *fiber.Ctx) (string, error) {
token := c.FormValue(param)
if token == "" {
return "", errMissingForm
}
return token, nil
}
} | Class | 2 |
func CsrfFromForm(param string) func(c *fiber.Ctx) (string, error) {
return func(c *fiber.Ctx) (string, error) {
token := c.FormValue(param)
if token == "" {
return "", errMissingForm
}
return token, nil
}
} | Compound | 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.