element_type
stringclasses 4
values | project_name
stringclasses 1
value | uuid
stringlengths 36
36
| name
stringlengths 0
346
| imports
stringlengths 0
2.67k
| structs
stringclasses 761
values | interfaces
stringclasses 22
values | file_location
stringclasses 545
values | code
stringlengths 26
8.07M
| global_vars
stringclasses 7
values | package
stringclasses 124
values | tags
stringclasses 1
value |
---|---|---|---|---|---|---|---|---|---|---|---|
function
|
openshift/openshift-tests-private
|
338858af-7448-4ba5-a4f7-95bc23c55b19
|
removeMinIO
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/loki_storage.go
|
func removeMinIO(oc *exutil.CLI) {
deleteNamespace(oc, minioNS)
}
|
netobserv
| |||||
function
|
openshift/openshift-tests-private
|
be694fee-8a4f-4ae2-adaf-b31decd4d0c3
|
WaitForDeploymentPodsToBeReady
|
['"context"', '"fmt"', '"strings"', '"time"', '"k8s.io/apimachinery/pkg/util/wait"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/loki_storage.go
|
func WaitForDeploymentPodsToBeReady(oc *exutil.CLI, namespace string, name string) {
var selectors map[string]string
err := wait.PollUntilContextTimeout(context.Background(), 5*time.Second, 180*time.Second, true, func(context.Context) (done bool, err error) {
deployment, err := oc.AdminKubeClient().AppsV1().Deployments(namespace).Get(context.Background(), name, metav1.GetOptions{})
if err != nil {
if apierrors.IsNotFound(err) {
e2e.Logf("Waiting for deployment/%s to appear\n", name)
return false, nil
}
return false, err
}
selectors = deployment.Spec.Selector.MatchLabels
if deployment.Status.AvailableReplicas == *deployment.Spec.Replicas && deployment.Status.UpdatedReplicas == *deployment.Spec.Replicas {
e2e.Logf("Deployment %s available (%d/%d)\n", name, deployment.Status.AvailableReplicas, *deployment.Spec.Replicas)
return true, nil
}
e2e.Logf("Waiting for full availability of %s deployment (%d/%d)\n", name, deployment.Status.AvailableReplicas, *deployment.Spec.Replicas)
return false, nil
})
if err != nil && len(selectors) > 0 {
var labels []string
for k, v := range selectors {
labels = append(labels, k+"="+v)
}
label := strings.Join(labels, ",")
_ = oc.AsAdmin().WithoutNamespace().Run("get").Args("pod", "-n", namespace, "-l", label).Execute()
podStatus, _ := oc.AsAdmin().WithoutNamespace().Run("get").Args("pod", "-n", namespace, "-l", label, "-ojsonpath={.items[*].status.conditions}").Output()
containerStatus, _ := oc.AsAdmin().WithoutNamespace().Run("get").Args("pod", "-n", namespace, "-l", label, "-ojsonpath={.items[*].status.containerStatuses}").Output()
e2e.Failf("deployment %s is not ready:\nconditions: %s\ncontainer status: %s", name, podStatus, containerStatus)
}
exutil.AssertWaitPollNoErr(err, fmt.Sprintf("deployment %s is not available", name))
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
ea587d28-8379-4675-8fe6-b5f098328eb6
|
WaitForResourceToAppear
|
['"context"', '"fmt"', '"strings"', '"time"', '"k8s.io/apimachinery/pkg/util/wait"']
|
['resource']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/loki_storage.go
|
func (r resource) WaitForResourceToAppear(oc *exutil.CLI) {
err := wait.PollUntilContextTimeout(context.Background(), 3*time.Second, 180*time.Second, true, func(context.Context) (done bool, err error) {
output, err := oc.AsAdmin().WithoutNamespace().Run("get").Args("-n", r.namespace, r.kind, r.name).Output()
if err != nil {
msg := fmt.Sprintf("%v", output)
if strings.Contains(msg, "NotFound") {
return false, nil
}
return false, err
}
e2e.Logf("Find %s %s", r.kind, r.name)
return true, nil
})
exutil.AssertWaitPollNoErr(err, fmt.Sprintf("resource %s/%s is not appear", r.kind, r.name))
}
|
netobserv
| |||
function
|
openshift/openshift-tests-private
|
c3abed16-0d5c-4fa1-9706-f17ffa096e4a
|
generateServiceAccountNameForGCS
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/loki_storage.go
|
func generateServiceAccountNameForGCS(clusterName string) string {
// Service Account should be between 6-30 characters long
name := clusterName + getRandomString()
return name
}
|
netobserv
| |||||
function
|
openshift/openshift-tests-private
|
fba79ae9-dc2b-40ab-b69d-0794bb27ed0f
|
readAzureCredentials
|
['"os"', '"path/filepath"', '"github.com/tidwall/gjson"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/loki_storage.go
|
func readAzureCredentials() bool {
var azureCredFile string
envDir, present := os.LookupEnv("CLUSTER_PROFILE_DIR")
if present {
azureCredFile = filepath.Join(envDir, "osServicePrincipal.json")
} else {
authFileLocation, present := os.LookupEnv("AZURE_AUTH_LOCATION")
if present {
azureCredFile = authFileLocation
}
}
if len(azureCredFile) > 0 {
fileContent, err := os.ReadFile(azureCredFile)
o.Expect(err).NotTo(o.HaveOccurred())
subscriptionID := gjson.Get(string(fileContent), `azure_subscription_id`).String()
if subscriptionID == "" {
subscriptionID = gjson.Get(string(fileContent), `subscriptionId`).String()
}
os.Setenv("AZURE_SUBSCRIPTION_ID", subscriptionID)
tenantID := gjson.Get(string(fileContent), `azure_tenant_id`).String()
if tenantID == "" {
tenantID = gjson.Get(string(fileContent), `tenantId`).String()
}
os.Setenv("AZURE_TENANT_ID", tenantID)
clientID := gjson.Get(string(fileContent), `azure_client_id`).String()
if clientID == "" {
clientID = gjson.Get(string(fileContent), `clientId`).String()
}
os.Setenv("AZURE_CLIENT_ID", clientID)
clientSecret := gjson.Get(string(fileContent), `azure_client_secret`).String()
if clientSecret == "" {
clientSecret = gjson.Get(string(fileContent), `clientSecret`).String()
}
os.Setenv("AZURE_CLIENT_SECRET", clientSecret)
return true
}
return false
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
c89b48bf-a504-49c5-a1fc-8fed1fe65a08
|
getGCPProjectNumber
|
['"context"', '"strconv"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/loki_storage.go
|
func getGCPProjectNumber(projectID string) (string, error) {
crmService, err := cloudresourcemanager.NewService(context.Background())
if err != nil {
return "", err
}
project, err := crmService.Projects.Get(projectID).Do()
if err != nil {
return "", err
}
return strconv.FormatInt(project.ProjectNumber, 10), nil
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
cf0ffd8b-9be9-45c9-ac26-ea85afb78361
|
getPoolID
|
['"strings"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/loki_storage.go
|
func getPoolID(oc *exutil.CLI) (string, error) {
// pool_id="$(oc get authentication cluster -o json | jq -r .spec.serviceAccountIssuer | sed 's/.*\/\([^\/]*\)-oidc/\1/')"
issuer, err := getOIDC(oc)
if err != nil {
return "", err
}
return strings.Split(strings.Split(issuer, "/")[1], "-oidc")[0], nil
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
dad42d6e-83c4-44af-afb3-c51a4adafe8f
|
createServiceAccountOnGCP
|
['"context"', '"fmt"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/loki_storage.go
|
func createServiceAccountOnGCP(projectID, name string) (*iam.ServiceAccount, error) {
e2e.Logf("start to creating serviceaccount on GCP")
ctx := context.Background()
service, err := iam.NewService(ctx)
if err != nil {
return nil, fmt.Errorf("iam.NewService: %w", err)
}
request := &iam.CreateServiceAccountRequest{
AccountId: name,
ServiceAccount: &iam.ServiceAccount{
DisplayName: "Service Account for " + name,
},
}
account, err := service.Projects.ServiceAccounts.Create("projects/"+projectID, request).Do()
if err != nil {
return nil, fmt.Errorf("failed to create serviceaccount: %w", err)
}
e2e.Logf("Created service account: %v", account)
return account, nil
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
fb650d10-e9d2-4dab-8aa6-697b8c31ce2d
|
grantPermissionsToGCPServiceAccount
|
['"fmt"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/loki_storage.go
|
func grantPermissionsToGCPServiceAccount(poolID, projectID, projectNumber, lokiNS, lokiStackName, serviceAccountEmail string) error {
gcsRoles := []string{
"roles/iam.workloadIdentityUser",
"roles/storage.objectAdmin",
}
subjects := []string{
"system:serviceaccount:" + lokiNS + ":" + lokiStackName,
"system:serviceaccount:" + lokiNS + ":" + lokiStackName + "-ruler",
}
for _, role := range gcsRoles {
err := addBinding(projectID, "serviceAccount:"+serviceAccountEmail, role)
if err != nil {
return fmt.Errorf("error adding role %s to %s: %v", role, serviceAccountEmail, err)
}
for _, sub := range subjects {
err := addBinding(projectID, "principal://iam.googleapis.com/projects/"+projectNumber+"/locations/global/workloadIdentityPools/"+poolID+"/subject/"+sub, role)
if err != nil {
return fmt.Errorf("error adding role %s to %s: %v", role, sub, err)
}
}
}
return nil
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
cc9296ea-e7e3-41fa-a896-e37ba0bbb291
|
addBinding
|
['"context"', '"fmt"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/loki_storage.go
|
func addBinding(projectID, member, role string) error {
crmService, err := cloudresourcemanager.NewService(context.Background())
if err != nil {
return fmt.Errorf("cloudresourcemanager.NewService: %v", err)
}
policy, err := getPolicy(crmService, projectID)
if err != nil {
return fmt.Errorf("error getting policy: %v", err)
}
// Find the policy binding for role. Only one binding can have the role.
var binding *cloudresourcemanager.Binding
for _, b := range policy.Bindings {
if b.Role == role {
binding = b
break
}
}
if binding != nil {
// If the binding exists, adds the member to the binding
binding.Members = append(binding.Members, member)
} else {
// If the binding does not exist, adds a new binding to the policy
binding = &cloudresourcemanager.Binding{
Role: role,
Members: []string{member},
}
policy.Bindings = append(policy.Bindings, binding)
}
return setPolicy(crmService, projectID, policy)
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
5a3de630-2b6a-4f82-8df5-671aba40107b
|
getPolicy
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/loki_storage.go
|
func getPolicy(crmService *cloudresourcemanager.Service, projectID string) (*cloudresourcemanager.Policy, error) {
request := new(cloudresourcemanager.GetIamPolicyRequest)
policy, err := crmService.Projects.GetIamPolicy(projectID, request).Do()
if err != nil {
return nil, err
}
return policy, nil
}
|
netobserv
| |||||
function
|
openshift/openshift-tests-private
|
0db55cb9-b911-4fb9-9024-230cc1979352
|
setPolicy
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/loki_storage.go
|
func setPolicy(crmService *cloudresourcemanager.Service, projectID string, policy *cloudresourcemanager.Policy) error {
request := new(cloudresourcemanager.SetIamPolicyRequest)
request.Policy = policy
_, err := crmService.Projects.SetIamPolicy(projectID, request).Do()
return err
}
|
netobserv
| |||||
function
|
openshift/openshift-tests-private
|
8563bef5-9202-4690-a1d4-43ae1e98fff3
|
createObjectBucketClaim
|
['resource']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/loki_storage.go
|
func createObjectBucketClaim(oc *exutil.CLI, ns, name string) error {
template := exutil.FixturePath("testdata", "logging", "odf", "objectBucketClaim.yaml")
obc := resource{"objectbucketclaims", name, ns}
err := obc.applyFromTemplate(oc, "-f", template, "-n", ns, "-p", "NAME="+name, "NAMESPACE="+ns)
if err != nil {
return err
}
obc.WaitForResourceToAppear(oc)
resource{"objectbuckets", "obc-" + ns + "-" + name, ns}.WaitForResourceToAppear(oc)
assertResourceStatus(oc, "objectbucketclaims", name, ns, "{.status.phase}", "Bound")
return nil
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
706cfb6f-03f6-4e6d-b27d-9cbad6ad85ff
|
applyFromTemplate
|
['"fmt"', '"os"']
|
['resource']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/loki_storage.go
|
func (r resource) applyFromTemplate(oc *exutil.CLI, parameters ...string) error {
parameters = append(parameters, "-n", r.namespace)
file, err := processTemplate(oc, parameters...)
defer os.Remove(file)
exutil.AssertWaitPollNoErr(err, fmt.Sprintf("Can not process %v", parameters))
output, err := oc.AsAdmin().WithoutNamespace().Run("apply").Args("-f", file, "-n", r.namespace).Output()
if err != nil {
return fmt.Errorf(output)
}
r.WaitForResourceToAppear(oc)
return nil
}
|
netobserv
| |||
function
|
openshift/openshift-tests-private
|
cc0cea1e-6e80-4582-a07d-524f90b350b6
|
assertResourceStatus
|
['"context"', '"fmt"', '"strings"', '"time"', '"k8s.io/apimachinery/pkg/util/wait"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/loki_storage.go
|
func assertResourceStatus(oc *exutil.CLI, kind, name, namespace, jsonpath, exptdStatus string) {
parameters := []string{kind, name, "-o", "jsonpath=" + jsonpath}
if namespace != "" {
parameters = append(parameters, "-n", namespace)
}
err := wait.PollUntilContextTimeout(context.Background(), 10*time.Second, 180*time.Second, true, func(context.Context) (done bool, err error) {
status, err := oc.AsAdmin().WithoutNamespace().Run("get").Args(parameters...).Output()
if err != nil {
return false, err
}
if strings.Compare(status, exptdStatus) != 0 {
return false, nil
}
return true, nil
})
exutil.AssertWaitPollNoErr(err, fmt.Sprintf("%s/%s value for %s is not %s", kind, name, jsonpath, exptdStatus))
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
1145915a-7829-450d-b038-f697a2f26c9c
|
createSecretForGCSBucketWithSTS
|
['"google.golang.org/api/cloudresourcemanager/v1"', '"google.golang.org/api/iam/v1"', 'metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/loki_storage.go
|
func createSecretForGCSBucketWithSTS(oc *exutil.CLI, projectNumber, poolID, serviceAccountEmail, ns, name, bucketName string) error {
providerName := "projects/" + projectNumber + "/locations/global/workloadIdentityPools/" + poolID + "/providers/" + poolID
audience, err := getGCPAudience(providerName)
if err != nil {
return err
}
key := `{
"universe_domain": "googleapis.com",
"type": "external_account",
"audience": "//iam.googleapis.com/` + providerName + `",
"subject_token_type": "urn:ietf:params:oauth:token-type:jwt",
"token_url": "https://sts.googleapis.com/v1/token",
"credential_source": {
"file": "/var/run/secrets/storage/serviceaccount/token",
"format": {
"type": "text"
}
},
"service_account_impersonation_url": "https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/` + serviceAccountEmail + `:generateAccessToken"
}`
return oc.NotShowInfo().AsAdmin().WithoutNamespace().Run("create").Args("secret", "generic", "-n", ns, name,
"--from-literal=bucketname="+bucketName, "--from-literal=audience="+audience, "--from-literal=key.json="+key).Execute()
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
e3e04dfc-e660-4067-80e2-2c43b6018d95
|
getGCPAudience
|
['"context"', '"fmt"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/loki_storage.go
|
func getGCPAudience(providerName string) (string, error) {
ctx := context.Background()
service, err := iam.NewService(ctx)
if err != nil {
return "", fmt.Errorf("iam.NewService: %w", err)
}
audience, err := service.Projects.Locations.WorkloadIdentityPools.Providers.Get(providerName).Do()
if err != nil {
return "", fmt.Errorf("can't get audience: %v", err)
}
return audience.Oidc.AllowedAudiences[0], nil
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
23380087-94c3-4975-99e1-f42633bd60f1
|
clear
|
['"fmt"', '"strings"']
|
['resource']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/loki_storage.go
|
func (r resource) clear(oc *exutil.CLI) error {
msg, err := oc.AsAdmin().WithoutNamespace().Run("delete").Args("-n", r.namespace, r.kind, r.name).Output()
if err != nil {
errstring := fmt.Sprintf("%v", msg)
if strings.Contains(errstring, "NotFound") || strings.Contains(errstring, "the server doesn't have a resource type") {
return nil
}
return err
}
err = r.WaitUntilResourceIsGone(oc)
return err
}
|
netobserv
| |||
function
|
openshift/openshift-tests-private
|
86ecfe1a-485c-4b0c-9832-f1d4c6f79474
|
WaitUntilResourceIsGone
|
['"context"', '"fmt"', '"strings"', '"time"', '"k8s.io/apimachinery/pkg/util/wait"']
|
['resource']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/loki_storage.go
|
func (r resource) WaitUntilResourceIsGone(oc *exutil.CLI) error {
err := wait.PollUntilContextTimeout(context.Background(), 3*time.Second, 180*time.Second, true, func(context.Context) (done bool, err error) {
output, err := oc.AsAdmin().WithoutNamespace().Run("get").Args("-n", r.namespace, r.kind, r.name).Output()
if err != nil {
errstring := fmt.Sprintf("%v", output)
if strings.Contains(errstring, "NotFound") || strings.Contains(errstring, "the server doesn't have a resource type") {
return true, nil
}
return true, err
}
return false, nil
})
if err != nil {
return fmt.Errorf("can't remove %s/%s in %s project", r.kind, r.name, r.namespace)
}
return nil
}
|
netobserv
| |||
function
|
openshift/openshift-tests-private
|
bcb5963f-2929-4021-8bf3-a3338f464373
|
removePermissionsFromGCPServiceAccount
|
['"fmt"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/loki_storage.go
|
func removePermissionsFromGCPServiceAccount(poolID, projectID, projectNumber, lokiNS, lokiStackName, serviceAccountEmail string) error {
gcsRoles := []string{
"roles/iam.workloadIdentityUser",
"roles/storage.objectAdmin",
}
subjects := []string{
"system:serviceaccount:" + lokiNS + ":" + lokiStackName,
"system:serviceaccount:" + lokiNS + ":" + lokiStackName + "-ruler",
}
for _, role := range gcsRoles {
err := removeMember(projectID, "serviceAccount:"+serviceAccountEmail, role)
if err != nil {
return fmt.Errorf("error removing role %s from %s: %v", role, serviceAccountEmail, err)
}
for _, sub := range subjects {
err := removeMember(projectID, "principal://iam.googleapis.com/projects/"+projectNumber+"/locations/global/workloadIdentityPools/"+poolID+"/subject/"+sub, role)
if err != nil {
return fmt.Errorf("error removing role %s from %s: %v", role, sub, err)
}
}
}
return nil
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
f94170f3-b05e-4d6a-b347-d438b4ddc7bd
|
removeServiceAccountFromGCP
|
['"context"', '"fmt"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/loki_storage.go
|
func removeServiceAccountFromGCP(name string) error {
ctx := context.Background()
service, err := iam.NewService(ctx)
if err != nil {
return fmt.Errorf("iam.NewService: %w", err)
}
_, err = service.Projects.ServiceAccounts.Delete(name).Do()
if err != nil {
return fmt.Errorf("can't remove service account: %v", err)
}
return nil
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
4fa17192-cbaf-473b-8bd1-992d7acc8ba3
|
removeMember
|
['"context"', '"fmt"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/loki_storage.go
|
func removeMember(projectID, member, role string) error {
crmService, err := cloudresourcemanager.NewService(context.Background())
if err != nil {
return fmt.Errorf("cloudresourcemanager.NewService: %v", err)
}
policy, err := getPolicy(crmService, projectID)
if err != nil {
return fmt.Errorf("error getting policy: %v", err)
}
// Find the policy binding for role. Only one binding can have the role.
var binding *cloudresourcemanager.Binding
var bindingIndex int
for i, b := range policy.Bindings {
if b.Role == role {
binding = b
bindingIndex = i
break
}
}
if len(binding.Members) == 1 && binding.Members[0] == member {
// If the member is the only member in the binding, removes the binding
last := len(policy.Bindings) - 1
policy.Bindings[bindingIndex] = policy.Bindings[last]
policy.Bindings = policy.Bindings[:last]
} else {
// If there is more than one member in the binding, removes the member
var memberIndex int
var exist bool
for i, mm := range binding.Members {
if mm == member {
memberIndex = i
exist = true
break
}
}
if exist {
last := len(policy.Bindings[bindingIndex].Members) - 1
binding.Members[memberIndex] = binding.Members[last]
binding.Members = binding.Members[:last]
}
}
return setPolicy(crmService, projectID, policy)
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
cf0d413c-08be-4eee-80fd-241d74ec95e6
|
deleteObjectBucketClaim
|
['resource']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/loki_storage.go
|
func deleteObjectBucketClaim(oc *exutil.CLI, ns, name string) error {
obc := resource{"objectbucketclaims", name, ns}
err := obc.clear(oc)
if err != nil {
return err
}
return obc.WaitUntilResourceIsGone(oc)
}
|
netobserv
| ||||
file
|
openshift/openshift-tests-private
|
f4e6a1aa-fad8-44e3-bb37-478610bb68e2
|
multitenants
|
import (
"context"
"fmt"
"os"
"os/exec"
filePath "path/filepath"
"reflect"
"time"
g "github.com/onsi/ginkgo/v2"
o "github.com/onsi/gomega"
exutil "github.com/openshift/openshift-tests-private/test/extended/util"
"k8s.io/apimachinery/pkg/util/wait"
e2e "k8s.io/kubernetes/test/e2e/framework"
)
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/multitenants.go
|
package netobserv
import (
"context"
"fmt"
"os"
"os/exec"
filePath "path/filepath"
"reflect"
"time"
g "github.com/onsi/ginkgo/v2"
o "github.com/onsi/gomega"
exutil "github.com/openshift/openshift-tests-private/test/extended/util"
"k8s.io/apimachinery/pkg/util/wait"
e2e "k8s.io/kubernetes/test/e2e/framework"
)
type User struct {
Username string
Password string
}
func getCoStatus(oc *exutil.CLI, coName string, statusToCompare map[string]string) map[string]string {
newStatusToCompare := make(map[string]string)
for key := range statusToCompare {
args := fmt.Sprintf(`-o=jsonpath={.status.conditions[?(.type == '%s')].status}`, key)
status, err := oc.AsAdmin().WithoutNamespace().Run("get").Args("co", args, coName).Output()
o.Expect(err).NotTo(o.HaveOccurred())
newStatusToCompare[key] = status
}
return newStatusToCompare
}
func waitCoBecomes(oc *exutil.CLI, coName string, waitTime int, expectedStatus map[string]string) error {
errCo := wait.PollUntilContextTimeout(context.Background(), 10*time.Second, time.Duration(waitTime)*time.Second, false, func(context.Context) (bool, error) {
gottenStatus := getCoStatus(oc, coName, expectedStatus)
eq := reflect.DeepEqual(expectedStatus, gottenStatus)
if eq {
eq := reflect.DeepEqual(expectedStatus, map[string]string{"Available": "True", "Progressing": "False", "Degraded": "False"})
if eq {
// For True False False, we want to wait some bit more time and double check, to ensure it is stably healthy
time.Sleep(25 * time.Second)
gottenStatus := getCoStatus(oc, coName, expectedStatus)
eq := reflect.DeepEqual(expectedStatus, gottenStatus)
if eq {
e2e.Logf("Given operator %s becomes available/non-progressing/non-degraded +%v", coName, gottenStatus)
return true, nil
}
} else {
e2e.Logf("Given operator %s becomes %s", coName, gottenStatus)
return true, nil
}
}
return false, nil
})
if errCo != nil {
err := oc.AsAdmin().WithoutNamespace().Run("get").Args("co").Execute()
o.Expect(err).NotTo(o.HaveOccurred())
}
return errCo
}
func generateUsersHtpasswd(passwdFile *string, users []*User) error {
for i := 0; i < len(users); i++ {
// Generate new username and password
username := fmt.Sprintf("testuser-%v-%v", i, exutil.GetRandomString())
password := exutil.GetRandomString()
users[i] = &User{Username: username, Password: password}
// Add new user to htpasswd file in the temp directory
cmd := fmt.Sprintf("htpasswd -b %v %v %v", *passwdFile, users[i].Username, users[i].Password)
err := exec.Command("bash", "-c", cmd).Run()
if err != nil {
return err
}
}
return nil
}
func getNewUser(oc *exutil.CLI, count int) ([]*User, string, string) {
usersDirPath := "/tmp/" + exutil.GetRandomString()
usersHTpassFile := usersDirPath + "/htpasswd"
err := os.MkdirAll(usersDirPath, 0o755)
o.Expect(err).NotTo(o.HaveOccurred())
htPassSecret, err := oc.AsAdmin().WithoutNamespace().Run("get").Args("oauth/cluster", "-o", "jsonpath={.spec.identityProviders[0].htpasswd.fileData.name}").Output()
o.Expect(err).NotTo(o.HaveOccurred())
users := make([]*User, count)
if htPassSecret == "" {
htPassSecret = "htpass-secret"
os.Create(usersHTpassFile)
err = generateUsersHtpasswd(&usersHTpassFile, users)
o.Expect(err).NotTo(o.HaveOccurred())
err = oc.AsAdmin().WithoutNamespace().Run("create").Args("-n", "openshift-config", "secret", "generic", htPassSecret, "--from-file", "htpasswd="+usersHTpassFile).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
err := oc.AsAdmin().WithoutNamespace().Run("patch").Args("--type=json", "-p", `[{"op": "add", "path": "/spec/identityProviders", "value": [{"htpasswd": {"fileData": {"name": "htpass-secret"}}, "mappingMethod": "claim", "name": "htpasswd", "type": "HTPasswd"}]}]`, "oauth/cluster").Execute()
o.Expect(err).NotTo(o.HaveOccurred())
} else {
err = oc.AsAdmin().WithoutNamespace().Run("extract").Args("-n", "openshift-config", "secret/"+htPassSecret, "--to", usersDirPath, "--confirm").Execute()
o.Expect(err).NotTo(o.HaveOccurred())
err = generateUsersHtpasswd(&usersHTpassFile, users)
o.Expect(err).NotTo(o.HaveOccurred())
// Update htpass-secret with the modified htpasswd file
err = oc.AsAdmin().WithoutNamespace().Run("set").Args("-n", "openshift-config", "data", "secret/"+htPassSecret, "--from-file", "htpasswd="+usersHTpassFile).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
}
g.By("Checking authentication operator should be in Progressing in 180 seconds")
err = waitCoBecomes(oc, "authentication", 180, map[string]string{"Progressing": "True"})
exutil.AssertWaitPollNoErr(err, "authentication operator did not start progressing in 180 seconds")
e2e.Logf("Checking authentication operator should be Available in 600 seconds")
err = waitCoBecomes(oc, "authentication", 600, map[string]string{"Available": "True", "Progressing": "False", "Degraded": "False"})
exutil.AssertWaitPollNoErr(err, "authentication operator did not become available in 600 seconds")
return users, usersHTpassFile, htPassSecret
}
func userCleanup(oc *exutil.CLI, users []*User, usersHTpassFile string, htPassSecret string) {
defer os.RemoveAll(usersHTpassFile)
for i := range users {
// Add new user to htpasswd file in the temp directory
cmd := fmt.Sprintf("htpasswd -D %v %v", usersHTpassFile, users[i].Username)
err := exec.Command("bash", "-c", cmd).Run()
o.Expect(err).NotTo(o.HaveOccurred())
}
// Update htpass-secret with the modified htpasswd file
err := oc.AsAdmin().WithoutNamespace().Run("set").Args("-n", "openshift-config", "data", "secret/"+htPassSecret, "--from-file", "htpasswd="+usersHTpassFile).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
g.By("Checking authentication operator should be in Progressing in 180 seconds")
err = waitCoBecomes(oc, "authentication", 180, map[string]string{"Progressing": "True"})
exutil.AssertWaitPollNoErr(err, "authentication operator did not start progressing in 180 seconds")
e2e.Logf("Checking authentication operator should be Available in 600 seconds")
err = waitCoBecomes(oc, "authentication", 600, map[string]string{"Available": "True", "Progressing": "False", "Degraded": "False"})
exutil.AssertWaitPollNoErr(err, "authentication operator did not become available in 600 seconds")
}
func addUserAsReader(oc *exutil.CLI, username string) {
baseDir := exutil.FixturePath("testdata", "netobserv")
readerCRBPath := filePath.Join(baseDir, "netobserv-reader-multitenant-crb.yaml")
parameters := []string{"-f", readerCRBPath, "-p", "USERNAME=" + username}
exutil.CreateClusterResourceFromTemplate(oc, parameters...)
}
func removeUserAsReader(oc *exutil.CLI, username string) {
err := oc.AsAdmin().WithoutNamespace().Run("adm").Args("policy", "remove-cluster-role-from-user", "netobserv-reader", username).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
}
func addTemplatePermissions(oc *exutil.CLI, username string) {
baseDir := exutil.FixturePath("testdata", "netobserv")
readerCRBPath := filePath.Join(baseDir, "testuser-template-crb.yaml")
parameters := []string{"-f", readerCRBPath, "-p", "USERNAME=" + username}
exutil.CreateClusterResourceFromTemplate(oc, parameters...)
}
func removeTemplatePermissions(oc *exutil.CLI, username string) {
baseDir := exutil.FixturePath("testdata", "netobserv")
readerCRBPath := filePath.Join(baseDir, "testuser-template-crb.yaml")
parameters := []string{"-f", readerCRBPath, "-p", "USERNAME=" + username}
configFile := exutil.ProcessTemplate(oc, parameters...)
err := oc.AsAdmin().WithoutNamespace().Run("delete").Args("-f", configFile).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
}
|
package netobserv
| ||||
function
|
openshift/openshift-tests-private
|
d7033683-c6f6-4224-8878-fa813aa11baf
|
getCoStatus
|
['"fmt"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/multitenants.go
|
func getCoStatus(oc *exutil.CLI, coName string, statusToCompare map[string]string) map[string]string {
newStatusToCompare := make(map[string]string)
for key := range statusToCompare {
args := fmt.Sprintf(`-o=jsonpath={.status.conditions[?(.type == '%s')].status}`, key)
status, err := oc.AsAdmin().WithoutNamespace().Run("get").Args("co", args, coName).Output()
o.Expect(err).NotTo(o.HaveOccurred())
newStatusToCompare[key] = status
}
return newStatusToCompare
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
3a0d40e5-b837-489b-af16-d234991f35eb
|
waitCoBecomes
|
['"context"', '"reflect"', '"time"', '"k8s.io/apimachinery/pkg/util/wait"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/multitenants.go
|
func waitCoBecomes(oc *exutil.CLI, coName string, waitTime int, expectedStatus map[string]string) error {
errCo := wait.PollUntilContextTimeout(context.Background(), 10*time.Second, time.Duration(waitTime)*time.Second, false, func(context.Context) (bool, error) {
gottenStatus := getCoStatus(oc, coName, expectedStatus)
eq := reflect.DeepEqual(expectedStatus, gottenStatus)
if eq {
eq := reflect.DeepEqual(expectedStatus, map[string]string{"Available": "True", "Progressing": "False", "Degraded": "False"})
if eq {
// For True False False, we want to wait some bit more time and double check, to ensure it is stably healthy
time.Sleep(25 * time.Second)
gottenStatus := getCoStatus(oc, coName, expectedStatus)
eq := reflect.DeepEqual(expectedStatus, gottenStatus)
if eq {
e2e.Logf("Given operator %s becomes available/non-progressing/non-degraded +%v", coName, gottenStatus)
return true, nil
}
} else {
e2e.Logf("Given operator %s becomes %s", coName, gottenStatus)
return true, nil
}
}
return false, nil
})
if errCo != nil {
err := oc.AsAdmin().WithoutNamespace().Run("get").Args("co").Execute()
o.Expect(err).NotTo(o.HaveOccurred())
}
return errCo
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
d6593536-8b70-46e1-b93a-1a0f99d0e1ae
|
generateUsersHtpasswd
|
['"fmt"', '"os/exec"']
|
['User']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/multitenants.go
|
func generateUsersHtpasswd(passwdFile *string, users []*User) error {
for i := 0; i < len(users); i++ {
// Generate new username and password
username := fmt.Sprintf("testuser-%v-%v", i, exutil.GetRandomString())
password := exutil.GetRandomString()
users[i] = &User{Username: username, Password: password}
// Add new user to htpasswd file in the temp directory
cmd := fmt.Sprintf("htpasswd -b %v %v %v", *passwdFile, users[i].Username, users[i].Password)
err := exec.Command("bash", "-c", cmd).Run()
if err != nil {
return err
}
}
return nil
}
|
netobserv
| |||
function
|
openshift/openshift-tests-private
|
35912148-da3a-4390-8629-0ae669480e95
|
getNewUser
|
['"os"']
|
['User']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/multitenants.go
|
func getNewUser(oc *exutil.CLI, count int) ([]*User, string, string) {
usersDirPath := "/tmp/" + exutil.GetRandomString()
usersHTpassFile := usersDirPath + "/htpasswd"
err := os.MkdirAll(usersDirPath, 0o755)
o.Expect(err).NotTo(o.HaveOccurred())
htPassSecret, err := oc.AsAdmin().WithoutNamespace().Run("get").Args("oauth/cluster", "-o", "jsonpath={.spec.identityProviders[0].htpasswd.fileData.name}").Output()
o.Expect(err).NotTo(o.HaveOccurred())
users := make([]*User, count)
if htPassSecret == "" {
htPassSecret = "htpass-secret"
os.Create(usersHTpassFile)
err = generateUsersHtpasswd(&usersHTpassFile, users)
o.Expect(err).NotTo(o.HaveOccurred())
err = oc.AsAdmin().WithoutNamespace().Run("create").Args("-n", "openshift-config", "secret", "generic", htPassSecret, "--from-file", "htpasswd="+usersHTpassFile).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
err := oc.AsAdmin().WithoutNamespace().Run("patch").Args("--type=json", "-p", `[{"op": "add", "path": "/spec/identityProviders", "value": [{"htpasswd": {"fileData": {"name": "htpass-secret"}}, "mappingMethod": "claim", "name": "htpasswd", "type": "HTPasswd"}]}]`, "oauth/cluster").Execute()
o.Expect(err).NotTo(o.HaveOccurred())
} else {
err = oc.AsAdmin().WithoutNamespace().Run("extract").Args("-n", "openshift-config", "secret/"+htPassSecret, "--to", usersDirPath, "--confirm").Execute()
o.Expect(err).NotTo(o.HaveOccurred())
err = generateUsersHtpasswd(&usersHTpassFile, users)
o.Expect(err).NotTo(o.HaveOccurred())
// Update htpass-secret with the modified htpasswd file
err = oc.AsAdmin().WithoutNamespace().Run("set").Args("-n", "openshift-config", "data", "secret/"+htPassSecret, "--from-file", "htpasswd="+usersHTpassFile).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
}
g.By("Checking authentication operator should be in Progressing in 180 seconds")
err = waitCoBecomes(oc, "authentication", 180, map[string]string{"Progressing": "True"})
exutil.AssertWaitPollNoErr(err, "authentication operator did not start progressing in 180 seconds")
e2e.Logf("Checking authentication operator should be Available in 600 seconds")
err = waitCoBecomes(oc, "authentication", 600, map[string]string{"Available": "True", "Progressing": "False", "Degraded": "False"})
exutil.AssertWaitPollNoErr(err, "authentication operator did not become available in 600 seconds")
return users, usersHTpassFile, htPassSecret
}
|
netobserv
| |||
function
|
openshift/openshift-tests-private
|
d9e18ec0-3b3c-45eb-a3df-ceefec2fd83b
|
userCleanup
|
['"fmt"', '"os"', '"os/exec"']
|
['User']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/multitenants.go
|
func userCleanup(oc *exutil.CLI, users []*User, usersHTpassFile string, htPassSecret string) {
defer os.RemoveAll(usersHTpassFile)
for i := range users {
// Add new user to htpasswd file in the temp directory
cmd := fmt.Sprintf("htpasswd -D %v %v", usersHTpassFile, users[i].Username)
err := exec.Command("bash", "-c", cmd).Run()
o.Expect(err).NotTo(o.HaveOccurred())
}
// Update htpass-secret with the modified htpasswd file
err := oc.AsAdmin().WithoutNamespace().Run("set").Args("-n", "openshift-config", "data", "secret/"+htPassSecret, "--from-file", "htpasswd="+usersHTpassFile).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
g.By("Checking authentication operator should be in Progressing in 180 seconds")
err = waitCoBecomes(oc, "authentication", 180, map[string]string{"Progressing": "True"})
exutil.AssertWaitPollNoErr(err, "authentication operator did not start progressing in 180 seconds")
e2e.Logf("Checking authentication operator should be Available in 600 seconds")
err = waitCoBecomes(oc, "authentication", 600, map[string]string{"Available": "True", "Progressing": "False", "Degraded": "False"})
exutil.AssertWaitPollNoErr(err, "authentication operator did not become available in 600 seconds")
}
|
netobserv
| |||
function
|
openshift/openshift-tests-private
|
3a150cf5-7191-4e51-a562-214f2f83810a
|
addUserAsReader
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/multitenants.go
|
func addUserAsReader(oc *exutil.CLI, username string) {
baseDir := exutil.FixturePath("testdata", "netobserv")
readerCRBPath := filePath.Join(baseDir, "netobserv-reader-multitenant-crb.yaml")
parameters := []string{"-f", readerCRBPath, "-p", "USERNAME=" + username}
exutil.CreateClusterResourceFromTemplate(oc, parameters...)
}
|
netobserv
| |||||
function
|
openshift/openshift-tests-private
|
03a7c347-f2ea-4474-80f9-e2258e7fa3f2
|
removeUserAsReader
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/multitenants.go
|
func removeUserAsReader(oc *exutil.CLI, username string) {
err := oc.AsAdmin().WithoutNamespace().Run("adm").Args("policy", "remove-cluster-role-from-user", "netobserv-reader", username).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
}
|
netobserv
| |||||
function
|
openshift/openshift-tests-private
|
fe113949-6314-4368-a27f-9c76eae3dc1a
|
addTemplatePermissions
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/multitenants.go
|
func addTemplatePermissions(oc *exutil.CLI, username string) {
baseDir := exutil.FixturePath("testdata", "netobserv")
readerCRBPath := filePath.Join(baseDir, "testuser-template-crb.yaml")
parameters := []string{"-f", readerCRBPath, "-p", "USERNAME=" + username}
exutil.CreateClusterResourceFromTemplate(oc, parameters...)
}
|
netobserv
| |||||
function
|
openshift/openshift-tests-private
|
9d1b9288-8713-4d99-877c-a1b3b20ade03
|
removeTemplatePermissions
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/multitenants.go
|
func removeTemplatePermissions(oc *exutil.CLI, username string) {
baseDir := exutil.FixturePath("testdata", "netobserv")
readerCRBPath := filePath.Join(baseDir, "testuser-template-crb.yaml")
parameters := []string{"-f", readerCRBPath, "-p", "USERNAME=" + username}
configFile := exutil.ProcessTemplate(oc, parameters...)
err := oc.AsAdmin().WithoutNamespace().Run("delete").Args("-f", configFile).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
}
|
netobserv
| |||||
file
|
openshift/openshift-tests-private
|
f718be08-9f99-470b-8480-3ea4f9ab31c4
|
ovs
|
import (
"context"
"strings"
"time"
exutil "github.com/openshift/openshift-tests-private/test/extended/util"
"k8s.io/apimachinery/pkg/util/wait"
e2e "k8s.io/kubernetes/test/e2e/framework"
)
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/ovs.go
|
package netobserv
import (
"context"
"strings"
"time"
exutil "github.com/openshift/openshift-tests-private/test/extended/util"
"k8s.io/apimachinery/pkg/util/wait"
e2e "k8s.io/kubernetes/test/e2e/framework"
)
// polls to check ovs-flows-config is created or deleted given shouldExist is true or false
func waitCnoConfigMapUpdate(oc *exutil.CLI, shouldExist bool) {
err := wait.PollUntilContextTimeout(context.Background(), 20*time.Second, 10*time.Minute, false, func(context.Context) (bool, error) {
// check whether ovs-flows-config config map exists in openshift-network-operator NS
_, stderr, _ := oc.AsAdmin().WithoutNamespace().Run("get").Args("cm", "ovs-flows-config", "-n", "openshift-network-operator").Outputs()
if stderr == "" && shouldExist {
return true, nil
}
if stderr != "" && !shouldExist {
return true, nil
}
return false, nil
})
exutil.AssertWaitPollNoErr(err, "ovs-flows-config ConfigMap is not updated")
}
// returns target configured in ovs-flows-config config map
func getOVSFlowsConfigTarget(oc *exutil.CLI, flowlogsPipelineDeployedAs string) (string, error) {
var template string
if flowlogsPipelineDeployedAs == "Deployment" {
template = "{{.data.sharedTarget}}"
}
if flowlogsPipelineDeployedAs == "DaemonSet" {
template = "{{.data.nodePort}}"
}
stdout, stderr, err := oc.AsAdmin().WithoutNamespace().Run("get").Args("cm", "ovs-flows-config", "-n", "openshift-network-operator").Template(template).Outputs()
if stderr != "" || err != nil {
e2e.Logf("Fetching ovs-flows-config configmap return err %s", stderr)
}
return stdout, err
}
// get flow collector IPs configured in OVS
func getOVSCollectorIP(oc *exutil.CLI) ([]string, error) {
jsonpath := "{.items[*].spec.containers[*].env[?(@.name==\"IPFIX_COLLECTORS\")].value}"
var collectors []string
stdout, err := oc.AsAdmin().WithoutNamespace().Run("get").Args("pods", "-n", "openshift-ovn-kubernetes", "-o", "jsonpath="+jsonpath).Output()
if err != nil {
return collectors, err
}
collectors = strings.Split(stdout, " ")
return collectors, nil
}
|
package netobserv
| ||||
function
|
openshift/openshift-tests-private
|
cc6b7653-5936-445c-89de-529302f2d1ff
|
waitCnoConfigMapUpdate
|
['"context"', '"time"', '"k8s.io/apimachinery/pkg/util/wait"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/ovs.go
|
func waitCnoConfigMapUpdate(oc *exutil.CLI, shouldExist bool) {
err := wait.PollUntilContextTimeout(context.Background(), 20*time.Second, 10*time.Minute, false, func(context.Context) (bool, error) {
// check whether ovs-flows-config config map exists in openshift-network-operator NS
_, stderr, _ := oc.AsAdmin().WithoutNamespace().Run("get").Args("cm", "ovs-flows-config", "-n", "openshift-network-operator").Outputs()
if stderr == "" && shouldExist {
return true, nil
}
if stderr != "" && !shouldExist {
return true, nil
}
return false, nil
})
exutil.AssertWaitPollNoErr(err, "ovs-flows-config ConfigMap is not updated")
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
aa88f86b-49b7-4430-979f-f080696f5d8b
|
getOVSFlowsConfigTarget
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/ovs.go
|
func getOVSFlowsConfigTarget(oc *exutil.CLI, flowlogsPipelineDeployedAs string) (string, error) {
var template string
if flowlogsPipelineDeployedAs == "Deployment" {
template = "{{.data.sharedTarget}}"
}
if flowlogsPipelineDeployedAs == "DaemonSet" {
template = "{{.data.nodePort}}"
}
stdout, stderr, err := oc.AsAdmin().WithoutNamespace().Run("get").Args("cm", "ovs-flows-config", "-n", "openshift-network-operator").Template(template).Outputs()
if stderr != "" || err != nil {
e2e.Logf("Fetching ovs-flows-config configmap return err %s", stderr)
}
return stdout, err
}
|
netobserv
| |||||
function
|
openshift/openshift-tests-private
|
69bf4a86-f486-412c-9aa4-ebd6e55ed4b4
|
getOVSCollectorIP
|
['"strings"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/ovs.go
|
func getOVSCollectorIP(oc *exutil.CLI) ([]string, error) {
jsonpath := "{.items[*].spec.containers[*].env[?(@.name==\"IPFIX_COLLECTORS\")].value}"
var collectors []string
stdout, err := oc.AsAdmin().WithoutNamespace().Run("get").Args("pods", "-n", "openshift-ovn-kubernetes", "-o", "jsonpath="+jsonpath).Output()
if err != nil {
return collectors, err
}
collectors = strings.Split(stdout, " ")
return collectors, nil
}
|
netobserv
| ||||
file
|
openshift/openshift-tests-private
|
f82fb956-383c-4e94-85f0-68ae1797951d
|
sctp
|
import (
"context"
"fmt"
"strings"
g "github.com/onsi/ginkgo/v2"
o "github.com/onsi/gomega"
exutil "github.com/openshift/openshift-tests-private/test/extended/util"
e2e "k8s.io/kubernetes/test/e2e/framework"
e2enode "k8s.io/kubernetes/test/e2e/framework/node"
)
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/sctp.go
|
package netobserv
import (
"context"
"fmt"
"strings"
g "github.com/onsi/ginkgo/v2"
o "github.com/onsi/gomega"
exutil "github.com/openshift/openshift-tests-private/test/extended/util"
e2e "k8s.io/kubernetes/test/e2e/framework"
e2enode "k8s.io/kubernetes/test/e2e/framework/node"
)
// enableSCTPModuleOnNode Manual way to enable sctp in a cluster
func enableSCTPModuleOnNode(oc *exutil.CLI, nodeName, role string) {
e2e.Logf("This is %s worker node: %s", role, nodeName)
checkSCTPCmd := "cat /sys/module/sctp/initstate"
output, err := exutil.DebugNodeWithChroot(oc, nodeName, "bash", "-c", checkSCTPCmd)
var installCmd string
if err != nil || !strings.Contains(output, "live") {
e2e.Logf("No sctp module installed, will enable sctp module!!!")
if strings.EqualFold(role, "rhel") {
// command for rhel nodes
installCmd = "yum install -y kernel-modules-extra-`uname -r` && insmod /usr/lib/modules/`uname -r`/kernel/net/sctp/sctp.ko.xz"
} else {
// command for rhcos nodes
installCmd = "modprobe sctp"
}
e2e.Logf("Install command is %s", installCmd)
// Try 3 times to enable sctp
o.Eventually(func() error {
_, installErr := exutil.DebugNodeWithChroot(oc, nodeName, "bash", "-c", installCmd)
if installErr != nil && strings.EqualFold(role, "rhel") {
e2e.Logf("%v", installErr)
g.Skip("Yum insall to enable sctp cannot work in a disconnected cluster, skip the test!!!")
}
return installErr
}, "15s", "5s").ShouldNot(o.HaveOccurred(), fmt.Sprintf("Failed to install sctp module on node %s", nodeName))
// Wait for sctp applied
o.Eventually(func() string {
output, err := exutil.DebugNodeWithChroot(oc, nodeName, "bash", "-c", checkSCTPCmd)
if err != nil {
e2e.Logf("Wait for sctp applied, %v", err)
}
return output
}, "60s", "10s").Should(o.ContainSubstring("live"), fmt.Sprintf("Failed to load sctp module on node %s", nodeName))
} else {
e2e.Logf("sctp module is loaded on node %s\n%s", nodeName, output)
}
}
func prepareSCTPModule(oc *exutil.CLI) {
nodesOutput, err := oc.AsAdmin().WithoutNamespace().Run("get").Args("node").Output()
o.Expect(err).NotTo(o.HaveOccurred())
if strings.Contains(nodesOutput, "SchedulingDisabled") || strings.Contains(nodesOutput, "NotReady") {
g.Skip("There are already some nodes in NotReady or SchedulingDisabled status in cluster, skip the test!!! ")
}
workerNodeList, err := e2enode.GetReadySchedulableNodes(context.TODO(), oc.KubeFramework().ClientSet)
if err != nil || len(workerNodeList.Items) == 0 {
g.Skip("Can not find any woker nodes in the cluster")
}
// Will enable sctp by command
rhelWorkers, err := exutil.GetAllWorkerNodesByOSID(oc, "rhel")
o.Expect(err).NotTo(o.HaveOccurred())
if len(rhelWorkers) > 0 {
e2e.Logf("There are %v number rhel workers in this cluster, will use manual way to load sctp module.", len(rhelWorkers))
for _, worker := range rhelWorkers {
enableSCTPModuleOnNode(oc, worker, "rhel")
}
}
rhcosWorkers, err := exutil.GetAllWorkerNodesByOSID(oc, "rhcos")
o.Expect(err).NotTo(o.HaveOccurred())
e2e.Logf("%v", rhcosWorkers)
if len(rhcosWorkers) > 0 {
for _, worker := range rhcosWorkers {
enableSCTPModuleOnNode(oc, worker, "rhcos")
}
}
}
|
package netobserv
| ||||
function
|
openshift/openshift-tests-private
|
2ea799aa-8056-4dda-9ee7-738b3c0ee1ae
|
enableSCTPModuleOnNode
|
['"fmt"', '"strings"', 'e2enode "k8s.io/kubernetes/test/e2e/framework/node"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/sctp.go
|
func enableSCTPModuleOnNode(oc *exutil.CLI, nodeName, role string) {
e2e.Logf("This is %s worker node: %s", role, nodeName)
checkSCTPCmd := "cat /sys/module/sctp/initstate"
output, err := exutil.DebugNodeWithChroot(oc, nodeName, "bash", "-c", checkSCTPCmd)
var installCmd string
if err != nil || !strings.Contains(output, "live") {
e2e.Logf("No sctp module installed, will enable sctp module!!!")
if strings.EqualFold(role, "rhel") {
// command for rhel nodes
installCmd = "yum install -y kernel-modules-extra-`uname -r` && insmod /usr/lib/modules/`uname -r`/kernel/net/sctp/sctp.ko.xz"
} else {
// command for rhcos nodes
installCmd = "modprobe sctp"
}
e2e.Logf("Install command is %s", installCmd)
// Try 3 times to enable sctp
o.Eventually(func() error {
_, installErr := exutil.DebugNodeWithChroot(oc, nodeName, "bash", "-c", installCmd)
if installErr != nil && strings.EqualFold(role, "rhel") {
e2e.Logf("%v", installErr)
g.Skip("Yum insall to enable sctp cannot work in a disconnected cluster, skip the test!!!")
}
return installErr
}, "15s", "5s").ShouldNot(o.HaveOccurred(), fmt.Sprintf("Failed to install sctp module on node %s", nodeName))
// Wait for sctp applied
o.Eventually(func() string {
output, err := exutil.DebugNodeWithChroot(oc, nodeName, "bash", "-c", checkSCTPCmd)
if err != nil {
e2e.Logf("Wait for sctp applied, %v", err)
}
return output
}, "60s", "10s").Should(o.ContainSubstring("live"), fmt.Sprintf("Failed to load sctp module on node %s", nodeName))
} else {
e2e.Logf("sctp module is loaded on node %s\n%s", nodeName, output)
}
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
92ab858a-c7a7-4260-bea5-8f215cb6a509
|
prepareSCTPModule
|
['"context"', '"strings"', 'e2enode "k8s.io/kubernetes/test/e2e/framework/node"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/sctp.go
|
func prepareSCTPModule(oc *exutil.CLI) {
nodesOutput, err := oc.AsAdmin().WithoutNamespace().Run("get").Args("node").Output()
o.Expect(err).NotTo(o.HaveOccurred())
if strings.Contains(nodesOutput, "SchedulingDisabled") || strings.Contains(nodesOutput, "NotReady") {
g.Skip("There are already some nodes in NotReady or SchedulingDisabled status in cluster, skip the test!!! ")
}
workerNodeList, err := e2enode.GetReadySchedulableNodes(context.TODO(), oc.KubeFramework().ClientSet)
if err != nil || len(workerNodeList.Items) == 0 {
g.Skip("Can not find any woker nodes in the cluster")
}
// Will enable sctp by command
rhelWorkers, err := exutil.GetAllWorkerNodesByOSID(oc, "rhel")
o.Expect(err).NotTo(o.HaveOccurred())
if len(rhelWorkers) > 0 {
e2e.Logf("There are %v number rhel workers in this cluster, will use manual way to load sctp module.", len(rhelWorkers))
for _, worker := range rhelWorkers {
enableSCTPModuleOnNode(oc, worker, "rhel")
}
}
rhcosWorkers, err := exutil.GetAllWorkerNodesByOSID(oc, "rhcos")
o.Expect(err).NotTo(o.HaveOccurred())
e2e.Logf("%v", rhcosWorkers)
if len(rhcosWorkers) > 0 {
for _, worker := range rhcosWorkers {
enableSCTPModuleOnNode(oc, worker, "rhcos")
}
}
}
|
netobserv
| ||||
file
|
openshift/openshift-tests-private
|
733e992b-2792-4aaf-84d0-716e76676eca
|
aws_sts
|
import (
"context"
"fmt"
"os"
"path/filepath"
"strings"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
awsConfig "github.com/aws/aws-sdk-go-v2/config"
awsCred "github.com/aws/aws-sdk-go-v2/credentials"
"github.com/aws/aws-sdk-go-v2/service/iam"
"github.com/aws/aws-sdk-go-v2/service/s3"
s3Types "github.com/aws/aws-sdk-go-v2/service/s3/types"
"github.com/aws/aws-sdk-go-v2/service/sts"
g "github.com/onsi/ginkgo/v2"
o "github.com/onsi/gomega"
exutil "github.com/openshift/openshift-tests-private/test/extended/util"
"k8s.io/apimachinery/pkg/util/wait"
e2e "k8s.io/kubernetes/test/e2e/framework"
)
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/aws_sts.go
|
package netobserv
import (
"context"
"fmt"
"os"
"path/filepath"
"strings"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
awsConfig "github.com/aws/aws-sdk-go-v2/config"
awsCred "github.com/aws/aws-sdk-go-v2/credentials"
"github.com/aws/aws-sdk-go-v2/service/iam"
"github.com/aws/aws-sdk-go-v2/service/s3"
s3Types "github.com/aws/aws-sdk-go-v2/service/s3/types"
"github.com/aws/aws-sdk-go-v2/service/sts"
g "github.com/onsi/ginkgo/v2"
o "github.com/onsi/gomega"
exutil "github.com/openshift/openshift-tests-private/test/extended/util"
"k8s.io/apimachinery/pkg/util/wait"
e2e "k8s.io/kubernetes/test/e2e/framework"
)
// Check if credentials exist for STS clusters
func checkAWSCredentials() bool {
//set AWS_SHARED_CREDENTIALS_FILE from CLUSTER_PROFILE_DIR as the first priority"
prowConfigDir, present := os.LookupEnv("CLUSTER_PROFILE_DIR")
if present {
awsCredFile := filepath.Join(prowConfigDir, ".awscred")
if _, err := os.Stat(awsCredFile); err == nil {
err := os.Setenv("AWS_SHARED_CREDENTIALS_FILE", awsCredFile)
if err == nil {
e2e.Logf("use CLUSTER_PROFILE_DIR/.awscred")
return true
}
}
}
// check if AWS_SHARED_CREDENTIALS_FILE exist
_, present = os.LookupEnv("AWS_SHARED_CREDENTIALS_FILE")
if present {
e2e.Logf("use Env AWS_SHARED_CREDENTIALS_FILE")
return true
}
// check if AWS_SECRET_ACCESS_KEY exist
_, keyIDPresent := os.LookupEnv("AWS_ACCESS_KEY_ID")
_, keyPresent := os.LookupEnv("AWS_SECRET_ACCESS_KEY")
if keyIDPresent && keyPresent {
e2e.Logf("use Env AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY")
return true
}
// check if $HOME/.aws/credentials exist
home, _ := os.UserHomeDir()
if _, err := os.Stat(home + "/.aws/credentials"); err == nil {
e2e.Logf("use HOME/.aws/credentials")
return true
}
return false
}
// get AWS Account ID
func getAwsAccount(stsClient *sts.Client) (string, string) {
result, err := stsClient.GetCallerIdentity(context.TODO(), &sts.GetCallerIdentityInput{})
o.Expect(err).NotTo(o.HaveOccurred())
awsAccount := aws.ToString(result.Account)
awsUserArn := aws.ToString(result.Arn)
return awsAccount, awsUserArn
}
func readDefaultSDKExternalConfigurations(ctx context.Context, region string) aws.Config {
cfg, err := awsConfig.LoadDefaultConfig(ctx,
awsConfig.WithRegion(region),
)
o.Expect(err).NotTo(o.HaveOccurred())
return cfg
}
// new AWS STS client
func newStsClient(cfg aws.Config) *sts.Client {
if !checkAWSCredentials() {
g.Skip("Skip since no AWS credetial! No Env AWS_SHARED_CREDENTIALS_FILE, Env CLUSTER_PROFILE_DIR or $HOME/.aws/credentials file")
}
return sts.NewFromConfig(cfg)
}
// Create AWS IAM client
func newIamClient(cfg aws.Config) *iam.Client {
if !checkAWSCredentials() {
g.Skip("Skip since no AWS credetial! No Env AWS_SHARED_CREDENTIALS_FILE, Env CLUSTER_PROFILE_DIR or $HOME/.aws/credentials file")
}
return iam.NewFromConfig(cfg)
}
// aws iam create-role
func iamCreateRole(iamClient *iam.Client, trustPolicy string, roleName string) string {
e2e.Logf("Create iam role %v", roleName)
result, err := iamClient.CreateRole(context.TODO(), &iam.CreateRoleInput{
AssumeRolePolicyDocument: aws.String(trustPolicy),
RoleName: aws.String(roleName),
})
o.Expect(err).NotTo(o.HaveOccurred(), "couldn't create role "+roleName)
roleArn := aws.ToString(result.Role.Arn)
return roleArn
}
// aws iam delete-role
func iamDeleteRole(iamClient *iam.Client, roleName string) {
_, err := iamClient.DeleteRole(context.TODO(), &iam.DeleteRoleInput{
RoleName: aws.String(roleName),
})
if err != nil {
e2e.Logf("Couldn't delete role %s: %v", roleName, err)
}
}
// aws iam create-policy
func iamCreatePolicy(iamClient *iam.Client, mgmtPolicy string, policyName string) string {
e2e.Logf("Create iam policy %v", policyName)
result, err := iamClient.CreatePolicy(context.TODO(), &iam.CreatePolicyInput{
PolicyDocument: aws.String(mgmtPolicy),
PolicyName: aws.String(policyName),
})
o.Expect(err).NotTo(o.HaveOccurred(), "Couldn't create policy"+policyName)
policyArn := aws.ToString(result.Policy.Arn)
return policyArn
}
// aws iam delete-policy
func iamDeletePolicy(iamClient *iam.Client, policyArn string) {
_, err := iamClient.DeletePolicy(context.TODO(), &iam.DeletePolicyInput{
PolicyArn: aws.String(policyArn),
})
if err != nil {
e2e.Logf("Couldn't delete policy %v: %v", policyArn, err)
}
}
// This func creates a IAM role, attaches custom trust policy and managed permission policy
func createIAMRoleOnAWS(iamClient *iam.Client, trustPolicy string, roleName string, policyArn string) string {
result, err := iamClient.CreateRole(context.TODO(), &iam.CreateRoleInput{
AssumeRolePolicyDocument: aws.String(trustPolicy),
RoleName: aws.String(roleName),
})
o.Expect(err).NotTo(o.HaveOccurred(), "Couldn't create role %v", roleName)
roleArn := aws.ToString(result.Role.Arn)
//Adding managed permission policy if provided
if policyArn != "" {
_, err = iamClient.AttachRolePolicy(context.TODO(), &iam.AttachRolePolicyInput{
PolicyArn: aws.String(policyArn),
RoleName: aws.String(roleName),
})
o.Expect(err).NotTo(o.HaveOccurred())
}
return roleArn
}
// Deletes IAM role and attached policies
func deleteIAMroleonAWS(iamClient *iam.Client, roleName string) {
// List attached policies of the IAM role
listAttachedPoliciesOutput, err := iamClient.ListAttachedRolePolicies(context.TODO(), &iam.ListAttachedRolePoliciesInput{
RoleName: aws.String(roleName),
})
if err != nil {
e2e.Logf("Error listing attached policies of IAM role " + roleName)
}
if len(listAttachedPoliciesOutput.AttachedPolicies) == 0 {
e2e.Logf("No attached policies under IAM role: " + roleName)
}
if len(listAttachedPoliciesOutput.AttachedPolicies) != 0 {
// Detach attached policy from the IAM role
for _, policy := range listAttachedPoliciesOutput.AttachedPolicies {
_, err := iamClient.DetachRolePolicy(context.TODO(), &iam.DetachRolePolicyInput{
RoleName: aws.String(roleName),
PolicyArn: policy.PolicyArn,
})
if err != nil {
e2e.Logf("Error detaching policy: " + *policy.PolicyName)
} else {
e2e.Logf("Detached policy: " + *policy.PolicyName)
}
}
}
// Delete the IAM role
_, err = iamClient.DeleteRole(context.TODO(), &iam.DeleteRoleInput{
RoleName: aws.String(roleName),
})
if err != nil {
e2e.Logf("Error deleting IAM role: " + roleName)
} else {
e2e.Logf("IAM role deleted successfully: " + roleName)
}
}
// Create role_arn required for Loki deployment on STS clusters
func createIAMRoleForLokiSTSDeployment(iamClient *iam.Client, oidcName, awsAccountID, lokiNamespace, lokiStackName, roleName string) string {
policyArn := "arn:aws:iam::aws:policy/AmazonS3FullAccess"
lokiTrustPolicy := `{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Federated": "arn:aws:iam::%s:oidc-provider/%s"
},
"Action": "sts:AssumeRoleWithWebIdentity",
"Condition": {
"StringEquals": {
"%s:sub": [
"system:serviceaccount:%s:%s",
"system:serviceaccount:%s:%s-ruler"
]
}
}
}
]
}`
lokiTrustPolicy = fmt.Sprintf(lokiTrustPolicy, awsAccountID, oidcName, oidcName, lokiNamespace, lokiStackName, lokiNamespace, lokiStackName)
roleArn := createIAMRoleOnAWS(iamClient, lokiTrustPolicy, roleName, policyArn)
return roleArn
}
// Creates S3 bucket storage with STS
func createS3ObjectStorageBucketWithSTS(cfg aws.Config, stsClient *sts.Client, s3roleArn, bucketName string) {
// Check if bucket exists, if yes delete it
if checkIfS3bucketExistsWithSTS(cfg, stsClient, s3roleArn, bucketName) {
e2e.Logf("Bucket already exists. Deleting bucket")
deleteS3bucketWithSTS(cfg, stsClient, s3roleArn, bucketName)
}
result, err := stsClient.AssumeRole(context.TODO(), &sts.AssumeRoleInput{
RoleArn: &s3roleArn,
RoleSessionName: aws.String("logging_loki_sts_s3flow"),
})
o.Expect(err).NotTo(o.HaveOccurred())
// Creating S3 client with assumed role
s3Client := s3.NewFromConfig(cfg, func(options *s3.Options) {
options.Credentials = awsCred.NewStaticCredentialsProvider(
*result.Credentials.AccessKeyId,
*result.Credentials.SecretAccessKey,
*result.Credentials.SessionToken,
)
})
// Define the input for CreateBucket operation
createBucketInput := &s3.CreateBucketInput{
Bucket: aws.String(bucketName),
}
// Check if the region is us-east-1, do not specify a location constraint
if cfg.Region != "us-east-1" {
createBucketInput.CreateBucketConfiguration = &s3Types.CreateBucketConfiguration{
LocationConstraint: s3Types.BucketLocationConstraint(cfg.Region),
}
}
_, err = s3Client.CreateBucket(context.TODO(), createBucketInput)
o.Expect(err).NotTo(o.HaveOccurred(), "Failed to create bucket: "+bucketName)
}
// Creates Loki object storage secret on AWS STS cluster
func createObjectStorageSecretOnAWSSTSCluster(oc *exutil.CLI, region, storageSecret, bucketName, namespace string) {
err := oc.NotShowInfo().AsAdmin().WithoutNamespace().Run("create").Args("secret", "generic", storageSecret, "--from-literal=region="+region, "--from-literal=bucketnames="+bucketName, "--from-literal=audience=openshift", "-n", namespace).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
}
// Function to check if tenant logs are present under the S3 bucket.
// Returns success if any one of the tenants under tenants[] are found.
func validatesIfLogsArePushedToS3Bucket(s3Client *s3.Client, bucketName string, tenants []string) {
// Poll to check contents of the s3 bucket
err := wait.PollUntilContextTimeout(context.Background(), 30*time.Second, 300*time.Second, true, func(context.Context) (done bool, err error) {
listObjectsOutput, err := s3Client.ListObjectsV2(context.TODO(), &s3.ListObjectsV2Input{
Bucket: aws.String(bucketName),
})
if err != nil {
return false, err
}
for _, object := range listObjectsOutput.Contents {
for _, tenantName := range tenants {
if strings.Contains(*object.Key, tenantName) {
e2e.Logf("Logs " + *object.Key + " found under the bucket: " + bucketName)
return true, nil
}
}
}
e2e.Logf("Waiting for data to be available under bucket: " + bucketName)
return false, nil
})
exutil.AssertWaitPollNoErr(err, "Timed out...No data is available under the bucket: "+bucketName)
}
// This is an API operation that allows you to request temporary security credentials for accessing AWS
// resources by assuming an IAM (Identity and Access Management) role
func createS3AssumeRole(stsClient *sts.Client, iamClient *iam.Client, lokistackName string) (string, string) {
_, AWS_USER_ARN := getAwsAccount(stsClient)
assumeRoleName := lokistackName + "-" + exutil.GetRandomString()
policyArn := "arn:aws:iam::aws:policy/AmazonS3FullAccess"
s3trustPolicy := `{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "s3.amazonaws.com",
"AWS": "%s"
},
"Action": "sts:AssumeRole"
}
]
}`
s3trustPolicy = fmt.Sprintf(s3trustPolicy, AWS_USER_ARN)
s3roleArn := createIAMRoleOnAWS(iamClient, s3trustPolicy, assumeRoleName, policyArn)
// Waiting for a bit since it takes some time for the role creation to be propogated on AWS env.
time.Sleep(10 * time.Second)
return s3roleArn, assumeRoleName
}
func patchLokiOperatorWithAWSRoleArn(oc *exutil.CLI, packageName, lokiNamespace, roleArn string) {
roleArnPatchConfig := `{
"spec": {
"config": {
"env": [
{
"name": "ROLEARN",
"value": "%s"
}
]
}
}
}`
oc.NotShowInfo().AsAdmin().WithoutNamespace().Run("patch").Args("sub", packageName, "-n", lokiNamespace, "-p", fmt.Sprintf(roleArnPatchConfig, roleArn), "--type=merge").Execute()
WaitForPodsReadyWithLabel(oc, "openshift-operators-redhat", "name=loki-operator-controller-manager")
}
// Checks if a specific bucket exists under AWS S3 service
func checkIfS3bucketExistsWithSTS(cfg aws.Config, stsClient *sts.Client, s3assumeRoleArn string, bucketName string) bool {
assumeRoleInput := &sts.AssumeRoleInput{
RoleArn: &s3assumeRoleArn,
RoleSessionName: aws.String("checks3WithAssumeRole"),
}
assumeRoleOutput, err := stsClient.AssumeRole(context.Background(), assumeRoleInput)
o.Expect(err).NotTo(o.HaveOccurred())
// Creating S3 client with assumed role
s3Client := s3.NewFromConfig(cfg, func(options *s3.Options) {
options.Credentials = awsCred.NewStaticCredentialsProvider(
*assumeRoleOutput.Credentials.AccessKeyId,
*assumeRoleOutput.Credentials.SecretAccessKey,
*assumeRoleOutput.Credentials.SessionToken,
)
})
// Check if the bucket exists
_, err = s3Client.HeadBucket(context.TODO(), &s3.HeadBucketInput{
Bucket: &bucketName,
})
if err != nil {
if msg, errCode := err.(*s3Types.NoSuchBucket); errCode {
// Bucket does not exist
e2e.Logf("Bucket does not exist: %s", msg)
return false
} else {
e2e.Logf("Some other error accessing S3..Going ahead with bucket creation")
return false
}
}
// Bucket exists
return true
}
// Deletes a specific bucket's contents (if any) and the bucket itself within AWS S3
func deleteS3bucketWithSTS(cfg aws.Config, stsClient *sts.Client, s3assumeRoleArn string, bucketName string) {
assumeRoleOutput, err := stsClient.AssumeRole(context.TODO(), &sts.AssumeRoleInput{
RoleArn: aws.String(s3assumeRoleArn),
RoleSessionName: aws.String("AssumeRoleSession"),
})
o.Expect(err).NotTo(o.HaveOccurred())
// Creating S3 client with assumed role
s3Client := s3.NewFromConfig(cfg, func(options *s3.Options) {
options.Credentials = awsCred.NewStaticCredentialsProvider(
*assumeRoleOutput.Credentials.AccessKeyId,
*assumeRoleOutput.Credentials.SecretAccessKey,
*assumeRoleOutput.Credentials.SessionToken,
)
})
// List objects in the bucket
listObjectsOutput, err := s3Client.ListObjectsV2(context.TODO(), &s3.ListObjectsV2Input{
Bucket: aws.String(bucketName),
})
o.Expect(err).NotTo(o.HaveOccurred(), "Error listing bucket objects...")
if len(listObjectsOutput.Contents) != 0 {
// Delete each object individually
for _, obj := range listObjectsOutput.Contents {
_, err := s3Client.DeleteObject(context.TODO(), &s3.DeleteObjectInput{
Bucket: &bucketName,
Key: obj.Key,
})
o.Expect(err).NotTo(o.HaveOccurred(), "Error deleting bucket objects...")
}
}
// Delete the bucket
_, err = s3Client.DeleteBucket(context.TODO(), &s3.DeleteBucketInput{
Bucket: &bucketName,
})
if err != nil {
// If the bucket isn't empty, it will return an error
if msg, errCode := err.(*s3Types.NoSuchBucket); errCode {
e2e.Logf("Bucket does not exist: %s", msg)
} else {
e2e.Failf("Some Error deleting the bucket" + bucketName)
}
} else {
e2e.Logf("Bucket deleted successfully")
}
}
|
package netobserv
| ||||
function
|
openshift/openshift-tests-private
|
6a33d2bf-23d0-4055-a9a2-cb5c5201e913
|
checkAWSCredentials
|
['"os"', '"path/filepath"', '"github.com/aws/aws-sdk-go-v2/aws"', 'awsCred "github.com/aws/aws-sdk-go-v2/credentials"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/aws_sts.go
|
func checkAWSCredentials() bool {
//set AWS_SHARED_CREDENTIALS_FILE from CLUSTER_PROFILE_DIR as the first priority"
prowConfigDir, present := os.LookupEnv("CLUSTER_PROFILE_DIR")
if present {
awsCredFile := filepath.Join(prowConfigDir, ".awscred")
if _, err := os.Stat(awsCredFile); err == nil {
err := os.Setenv("AWS_SHARED_CREDENTIALS_FILE", awsCredFile)
if err == nil {
e2e.Logf("use CLUSTER_PROFILE_DIR/.awscred")
return true
}
}
}
// check if AWS_SHARED_CREDENTIALS_FILE exist
_, present = os.LookupEnv("AWS_SHARED_CREDENTIALS_FILE")
if present {
e2e.Logf("use Env AWS_SHARED_CREDENTIALS_FILE")
return true
}
// check if AWS_SECRET_ACCESS_KEY exist
_, keyIDPresent := os.LookupEnv("AWS_ACCESS_KEY_ID")
_, keyPresent := os.LookupEnv("AWS_SECRET_ACCESS_KEY")
if keyIDPresent && keyPresent {
e2e.Logf("use Env AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY")
return true
}
// check if $HOME/.aws/credentials exist
home, _ := os.UserHomeDir()
if _, err := os.Stat(home + "/.aws/credentials"); err == nil {
e2e.Logf("use HOME/.aws/credentials")
return true
}
return false
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
5e260cde-870e-494c-a6ec-7662556beb52
|
getAwsAccount
|
['"context"', '"github.com/aws/aws-sdk-go-v2/aws"', '"github.com/aws/aws-sdk-go-v2/service/sts"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/aws_sts.go
|
func getAwsAccount(stsClient *sts.Client) (string, string) {
result, err := stsClient.GetCallerIdentity(context.TODO(), &sts.GetCallerIdentityInput{})
o.Expect(err).NotTo(o.HaveOccurred())
awsAccount := aws.ToString(result.Account)
awsUserArn := aws.ToString(result.Arn)
return awsAccount, awsUserArn
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
7bebbef4-0ac3-42f7-9dd0-12c5215eae9a
|
readDefaultSDKExternalConfigurations
|
['"context"', '"github.com/aws/aws-sdk-go-v2/aws"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/aws_sts.go
|
func readDefaultSDKExternalConfigurations(ctx context.Context, region string) aws.Config {
cfg, err := awsConfig.LoadDefaultConfig(ctx,
awsConfig.WithRegion(region),
)
o.Expect(err).NotTo(o.HaveOccurred())
return cfg
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
84e9e102-1eca-4828-9e4c-a8ea2fd4166c
|
newStsClient
|
['"github.com/aws/aws-sdk-go-v2/aws"', 'awsCred "github.com/aws/aws-sdk-go-v2/credentials"', '"github.com/aws/aws-sdk-go-v2/service/sts"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/aws_sts.go
|
func newStsClient(cfg aws.Config) *sts.Client {
if !checkAWSCredentials() {
g.Skip("Skip since no AWS credetial! No Env AWS_SHARED_CREDENTIALS_FILE, Env CLUSTER_PROFILE_DIR or $HOME/.aws/credentials file")
}
return sts.NewFromConfig(cfg)
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
ab71baaa-30e9-4d94-b7a9-7afbfca551dd
|
newIamClient
|
['"github.com/aws/aws-sdk-go-v2/aws"', 'awsCred "github.com/aws/aws-sdk-go-v2/credentials"', '"github.com/aws/aws-sdk-go-v2/service/iam"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/aws_sts.go
|
func newIamClient(cfg aws.Config) *iam.Client {
if !checkAWSCredentials() {
g.Skip("Skip since no AWS credetial! No Env AWS_SHARED_CREDENTIALS_FILE, Env CLUSTER_PROFILE_DIR or $HOME/.aws/credentials file")
}
return iam.NewFromConfig(cfg)
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
581ebfd8-03ba-4f6a-9ce5-fea87b4abf5a
|
iamCreateRole
|
['"context"', '"github.com/aws/aws-sdk-go-v2/aws"', '"github.com/aws/aws-sdk-go-v2/service/iam"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/aws_sts.go
|
func iamCreateRole(iamClient *iam.Client, trustPolicy string, roleName string) string {
e2e.Logf("Create iam role %v", roleName)
result, err := iamClient.CreateRole(context.TODO(), &iam.CreateRoleInput{
AssumeRolePolicyDocument: aws.String(trustPolicy),
RoleName: aws.String(roleName),
})
o.Expect(err).NotTo(o.HaveOccurred(), "couldn't create role "+roleName)
roleArn := aws.ToString(result.Role.Arn)
return roleArn
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
cf77d6f7-60b6-4621-8655-6347e26ea9f5
|
iamDeleteRole
|
['"context"', '"github.com/aws/aws-sdk-go-v2/aws"', '"github.com/aws/aws-sdk-go-v2/service/iam"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/aws_sts.go
|
func iamDeleteRole(iamClient *iam.Client, roleName string) {
_, err := iamClient.DeleteRole(context.TODO(), &iam.DeleteRoleInput{
RoleName: aws.String(roleName),
})
if err != nil {
e2e.Logf("Couldn't delete role %s: %v", roleName, err)
}
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
d5faee94-5f17-4bd8-83eb-bdadb5c23502
|
iamCreatePolicy
|
['"context"', '"github.com/aws/aws-sdk-go-v2/aws"', '"github.com/aws/aws-sdk-go-v2/service/iam"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/aws_sts.go
|
func iamCreatePolicy(iamClient *iam.Client, mgmtPolicy string, policyName string) string {
e2e.Logf("Create iam policy %v", policyName)
result, err := iamClient.CreatePolicy(context.TODO(), &iam.CreatePolicyInput{
PolicyDocument: aws.String(mgmtPolicy),
PolicyName: aws.String(policyName),
})
o.Expect(err).NotTo(o.HaveOccurred(), "Couldn't create policy"+policyName)
policyArn := aws.ToString(result.Policy.Arn)
return policyArn
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
411d7004-4259-4ee8-a1cf-0247aab878a9
|
iamDeletePolicy
|
['"context"', '"github.com/aws/aws-sdk-go-v2/aws"', '"github.com/aws/aws-sdk-go-v2/service/iam"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/aws_sts.go
|
func iamDeletePolicy(iamClient *iam.Client, policyArn string) {
_, err := iamClient.DeletePolicy(context.TODO(), &iam.DeletePolicyInput{
PolicyArn: aws.String(policyArn),
})
if err != nil {
e2e.Logf("Couldn't delete policy %v: %v", policyArn, err)
}
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
1334e447-ddcb-4071-959b-d061ddf52175
|
createIAMRoleOnAWS
|
['"context"', '"github.com/aws/aws-sdk-go-v2/aws"', '"github.com/aws/aws-sdk-go-v2/service/iam"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/aws_sts.go
|
func createIAMRoleOnAWS(iamClient *iam.Client, trustPolicy string, roleName string, policyArn string) string {
result, err := iamClient.CreateRole(context.TODO(), &iam.CreateRoleInput{
AssumeRolePolicyDocument: aws.String(trustPolicy),
RoleName: aws.String(roleName),
})
o.Expect(err).NotTo(o.HaveOccurred(), "Couldn't create role %v", roleName)
roleArn := aws.ToString(result.Role.Arn)
//Adding managed permission policy if provided
if policyArn != "" {
_, err = iamClient.AttachRolePolicy(context.TODO(), &iam.AttachRolePolicyInput{
PolicyArn: aws.String(policyArn),
RoleName: aws.String(roleName),
})
o.Expect(err).NotTo(o.HaveOccurred())
}
return roleArn
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
d8c81c9b-19bd-4670-9e95-69502961586e
|
deleteIAMroleonAWS
|
['"context"', '"github.com/aws/aws-sdk-go-v2/aws"', '"github.com/aws/aws-sdk-go-v2/service/iam"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/aws_sts.go
|
func deleteIAMroleonAWS(iamClient *iam.Client, roleName string) {
// List attached policies of the IAM role
listAttachedPoliciesOutput, err := iamClient.ListAttachedRolePolicies(context.TODO(), &iam.ListAttachedRolePoliciesInput{
RoleName: aws.String(roleName),
})
if err != nil {
e2e.Logf("Error listing attached policies of IAM role " + roleName)
}
if len(listAttachedPoliciesOutput.AttachedPolicies) == 0 {
e2e.Logf("No attached policies under IAM role: " + roleName)
}
if len(listAttachedPoliciesOutput.AttachedPolicies) != 0 {
// Detach attached policy from the IAM role
for _, policy := range listAttachedPoliciesOutput.AttachedPolicies {
_, err := iamClient.DetachRolePolicy(context.TODO(), &iam.DetachRolePolicyInput{
RoleName: aws.String(roleName),
PolicyArn: policy.PolicyArn,
})
if err != nil {
e2e.Logf("Error detaching policy: " + *policy.PolicyName)
} else {
e2e.Logf("Detached policy: " + *policy.PolicyName)
}
}
}
// Delete the IAM role
_, err = iamClient.DeleteRole(context.TODO(), &iam.DeleteRoleInput{
RoleName: aws.String(roleName),
})
if err != nil {
e2e.Logf("Error deleting IAM role: " + roleName)
} else {
e2e.Logf("IAM role deleted successfully: " + roleName)
}
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
0f3a588e-9575-429f-ac8b-e1049eb89664
|
createIAMRoleForLokiSTSDeployment
|
['"fmt"', '"github.com/aws/aws-sdk-go-v2/aws"', '"github.com/aws/aws-sdk-go-v2/service/iam"', '"github.com/aws/aws-sdk-go-v2/service/sts"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/aws_sts.go
|
func createIAMRoleForLokiSTSDeployment(iamClient *iam.Client, oidcName, awsAccountID, lokiNamespace, lokiStackName, roleName string) string {
policyArn := "arn:aws:iam::aws:policy/AmazonS3FullAccess"
lokiTrustPolicy := `{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Federated": "arn:aws:iam::%s:oidc-provider/%s"
},
"Action": "sts:AssumeRoleWithWebIdentity",
"Condition": {
"StringEquals": {
"%s:sub": [
"system:serviceaccount:%s:%s",
"system:serviceaccount:%s:%s-ruler"
]
}
}
}
]
}`
lokiTrustPolicy = fmt.Sprintf(lokiTrustPolicy, awsAccountID, oidcName, oidcName, lokiNamespace, lokiStackName, lokiNamespace, lokiStackName)
roleArn := createIAMRoleOnAWS(iamClient, lokiTrustPolicy, roleName, policyArn)
return roleArn
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
fa855e6d-45d5-4b22-9350-06479f8203b6
|
createS3ObjectStorageBucketWithSTS
|
['"context"', '"github.com/aws/aws-sdk-go-v2/aws"', '"github.com/aws/aws-sdk-go-v2/service/s3"', '"github.com/aws/aws-sdk-go-v2/service/sts"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/aws_sts.go
|
func createS3ObjectStorageBucketWithSTS(cfg aws.Config, stsClient *sts.Client, s3roleArn, bucketName string) {
// Check if bucket exists, if yes delete it
if checkIfS3bucketExistsWithSTS(cfg, stsClient, s3roleArn, bucketName) {
e2e.Logf("Bucket already exists. Deleting bucket")
deleteS3bucketWithSTS(cfg, stsClient, s3roleArn, bucketName)
}
result, err := stsClient.AssumeRole(context.TODO(), &sts.AssumeRoleInput{
RoleArn: &s3roleArn,
RoleSessionName: aws.String("logging_loki_sts_s3flow"),
})
o.Expect(err).NotTo(o.HaveOccurred())
// Creating S3 client with assumed role
s3Client := s3.NewFromConfig(cfg, func(options *s3.Options) {
options.Credentials = awsCred.NewStaticCredentialsProvider(
*result.Credentials.AccessKeyId,
*result.Credentials.SecretAccessKey,
*result.Credentials.SessionToken,
)
})
// Define the input for CreateBucket operation
createBucketInput := &s3.CreateBucketInput{
Bucket: aws.String(bucketName),
}
// Check if the region is us-east-1, do not specify a location constraint
if cfg.Region != "us-east-1" {
createBucketInput.CreateBucketConfiguration = &s3Types.CreateBucketConfiguration{
LocationConstraint: s3Types.BucketLocationConstraint(cfg.Region),
}
}
_, err = s3Client.CreateBucket(context.TODO(), createBucketInput)
o.Expect(err).NotTo(o.HaveOccurred(), "Failed to create bucket: "+bucketName)
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
a96af4bf-d4a3-46d7-9fe6-92ab4ce8b4ed
|
createObjectStorageSecretOnAWSSTSCluster
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/aws_sts.go
|
func createObjectStorageSecretOnAWSSTSCluster(oc *exutil.CLI, region, storageSecret, bucketName, namespace string) {
err := oc.NotShowInfo().AsAdmin().WithoutNamespace().Run("create").Args("secret", "generic", storageSecret, "--from-literal=region="+region, "--from-literal=bucketnames="+bucketName, "--from-literal=audience=openshift", "-n", namespace).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
}
|
netobserv
| |||||
function
|
openshift/openshift-tests-private
|
2ef5eea1-5b3b-4010-b03a-0ed703ae3f6f
|
validatesIfLogsArePushedToS3Bucket
|
['"context"', '"strings"', '"time"', '"github.com/aws/aws-sdk-go-v2/aws"', '"github.com/aws/aws-sdk-go-v2/service/s3"', '"k8s.io/apimachinery/pkg/util/wait"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/aws_sts.go
|
func validatesIfLogsArePushedToS3Bucket(s3Client *s3.Client, bucketName string, tenants []string) {
// Poll to check contents of the s3 bucket
err := wait.PollUntilContextTimeout(context.Background(), 30*time.Second, 300*time.Second, true, func(context.Context) (done bool, err error) {
listObjectsOutput, err := s3Client.ListObjectsV2(context.TODO(), &s3.ListObjectsV2Input{
Bucket: aws.String(bucketName),
})
if err != nil {
return false, err
}
for _, object := range listObjectsOutput.Contents {
for _, tenantName := range tenants {
if strings.Contains(*object.Key, tenantName) {
e2e.Logf("Logs " + *object.Key + " found under the bucket: " + bucketName)
return true, nil
}
}
}
e2e.Logf("Waiting for data to be available under bucket: " + bucketName)
return false, nil
})
exutil.AssertWaitPollNoErr(err, "Timed out...No data is available under the bucket: "+bucketName)
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
a359ff4e-aacb-4254-8f12-36d3d93812b3
|
createS3AssumeRole
|
['"fmt"', '"time"', '"github.com/aws/aws-sdk-go-v2/aws"', '"github.com/aws/aws-sdk-go-v2/service/iam"', '"github.com/aws/aws-sdk-go-v2/service/s3"', '"github.com/aws/aws-sdk-go-v2/service/sts"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/aws_sts.go
|
func createS3AssumeRole(stsClient *sts.Client, iamClient *iam.Client, lokistackName string) (string, string) {
_, AWS_USER_ARN := getAwsAccount(stsClient)
assumeRoleName := lokistackName + "-" + exutil.GetRandomString()
policyArn := "arn:aws:iam::aws:policy/AmazonS3FullAccess"
s3trustPolicy := `{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "s3.amazonaws.com",
"AWS": "%s"
},
"Action": "sts:AssumeRole"
}
]
}`
s3trustPolicy = fmt.Sprintf(s3trustPolicy, AWS_USER_ARN)
s3roleArn := createIAMRoleOnAWS(iamClient, s3trustPolicy, assumeRoleName, policyArn)
// Waiting for a bit since it takes some time for the role creation to be propogated on AWS env.
time.Sleep(10 * time.Second)
return s3roleArn, assumeRoleName
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
8669f78a-63e7-4028-87a2-af41ffcb2b52
|
patchLokiOperatorWithAWSRoleArn
|
['"fmt"', 'awsConfig "github.com/aws/aws-sdk-go-v2/config"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/aws_sts.go
|
func patchLokiOperatorWithAWSRoleArn(oc *exutil.CLI, packageName, lokiNamespace, roleArn string) {
roleArnPatchConfig := `{
"spec": {
"config": {
"env": [
{
"name": "ROLEARN",
"value": "%s"
}
]
}
}
}`
oc.NotShowInfo().AsAdmin().WithoutNamespace().Run("patch").Args("sub", packageName, "-n", lokiNamespace, "-p", fmt.Sprintf(roleArnPatchConfig, roleArn), "--type=merge").Execute()
WaitForPodsReadyWithLabel(oc, "openshift-operators-redhat", "name=loki-operator-controller-manager")
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
3e720882-1d99-4c6f-9433-6b7b507904f9
|
checkIfS3bucketExistsWithSTS
|
['"context"', '"github.com/aws/aws-sdk-go-v2/aws"', '"github.com/aws/aws-sdk-go-v2/service/s3"', '"github.com/aws/aws-sdk-go-v2/service/sts"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/aws_sts.go
|
func checkIfS3bucketExistsWithSTS(cfg aws.Config, stsClient *sts.Client, s3assumeRoleArn string, bucketName string) bool {
assumeRoleInput := &sts.AssumeRoleInput{
RoleArn: &s3assumeRoleArn,
RoleSessionName: aws.String("checks3WithAssumeRole"),
}
assumeRoleOutput, err := stsClient.AssumeRole(context.Background(), assumeRoleInput)
o.Expect(err).NotTo(o.HaveOccurred())
// Creating S3 client with assumed role
s3Client := s3.NewFromConfig(cfg, func(options *s3.Options) {
options.Credentials = awsCred.NewStaticCredentialsProvider(
*assumeRoleOutput.Credentials.AccessKeyId,
*assumeRoleOutput.Credentials.SecretAccessKey,
*assumeRoleOutput.Credentials.SessionToken,
)
})
// Check if the bucket exists
_, err = s3Client.HeadBucket(context.TODO(), &s3.HeadBucketInput{
Bucket: &bucketName,
})
if err != nil {
if msg, errCode := err.(*s3Types.NoSuchBucket); errCode {
// Bucket does not exist
e2e.Logf("Bucket does not exist: %s", msg)
return false
} else {
e2e.Logf("Some other error accessing S3..Going ahead with bucket creation")
return false
}
}
// Bucket exists
return true
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
b3ad34d1-5d18-4c4b-8026-36fca96c78f5
|
deleteS3bucketWithSTS
|
['"context"', '"github.com/aws/aws-sdk-go-v2/aws"', '"github.com/aws/aws-sdk-go-v2/service/s3"', '"github.com/aws/aws-sdk-go-v2/service/sts"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/aws_sts.go
|
func deleteS3bucketWithSTS(cfg aws.Config, stsClient *sts.Client, s3assumeRoleArn string, bucketName string) {
assumeRoleOutput, err := stsClient.AssumeRole(context.TODO(), &sts.AssumeRoleInput{
RoleArn: aws.String(s3assumeRoleArn),
RoleSessionName: aws.String("AssumeRoleSession"),
})
o.Expect(err).NotTo(o.HaveOccurred())
// Creating S3 client with assumed role
s3Client := s3.NewFromConfig(cfg, func(options *s3.Options) {
options.Credentials = awsCred.NewStaticCredentialsProvider(
*assumeRoleOutput.Credentials.AccessKeyId,
*assumeRoleOutput.Credentials.SecretAccessKey,
*assumeRoleOutput.Credentials.SessionToken,
)
})
// List objects in the bucket
listObjectsOutput, err := s3Client.ListObjectsV2(context.TODO(), &s3.ListObjectsV2Input{
Bucket: aws.String(bucketName),
})
o.Expect(err).NotTo(o.HaveOccurred(), "Error listing bucket objects...")
if len(listObjectsOutput.Contents) != 0 {
// Delete each object individually
for _, obj := range listObjectsOutput.Contents {
_, err := s3Client.DeleteObject(context.TODO(), &s3.DeleteObjectInput{
Bucket: &bucketName,
Key: obj.Key,
})
o.Expect(err).NotTo(o.HaveOccurred(), "Error deleting bucket objects...")
}
}
// Delete the bucket
_, err = s3Client.DeleteBucket(context.TODO(), &s3.DeleteBucketInput{
Bucket: &bucketName,
})
if err != nil {
// If the bucket isn't empty, it will return an error
if msg, errCode := err.(*s3Types.NoSuchBucket); errCode {
e2e.Logf("Bucket does not exist: %s", msg)
} else {
e2e.Failf("Some Error deleting the bucket" + bucketName)
}
} else {
e2e.Logf("Bucket deleted successfully")
}
}
|
netobserv
| ||||
file
|
openshift/openshift-tests-private
|
8e592696-9176-417e-b227-46c15d3aaab5
|
azure_utils
|
import (
"context"
"fmt"
"os"
"strings"
"time"
azRuntime "github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime"
azTo "github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/authorization/armauthorization/v2"
"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/msi/armmsi"
"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage"
"github.com/Azure/azure-sdk-for-go/sdk/storage/azblob"
"github.com/google/uuid"
o "github.com/onsi/gomega"
exutil "github.com/openshift/openshift-tests-private/test/extended/util"
"k8s.io/apimachinery/pkg/util/wait"
e2e "k8s.io/kubernetes/test/e2e/framework"
)
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/azure_utils.go
|
package netobserv
import (
"context"
"fmt"
"os"
"strings"
"time"
azRuntime "github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime"
azTo "github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/authorization/armauthorization/v2"
"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/msi/armmsi"
"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage"
"github.com/Azure/azure-sdk-for-go/sdk/storage/azblob"
"github.com/google/uuid"
o "github.com/onsi/gomega"
exutil "github.com/openshift/openshift-tests-private/test/extended/util"
"k8s.io/apimachinery/pkg/util/wait"
e2e "k8s.io/kubernetes/test/e2e/framework"
)
// Creates a new default Azure credential
func createNewDefaultAzureCredential() *azidentity.DefaultAzureCredential {
cred, err := azidentity.NewDefaultAzureCredential(nil)
o.Expect(err).NotTo(o.HaveOccurred(), "Failed to obtain a credential")
return cred
}
// Function to create a managed identity on Azure
func createManagedIdentityOnAzure(defaultAzureCred *azidentity.DefaultAzureCredential, azureSubscriptionID, lokiStackName, resourceGroup, region string) (string, string) {
// Create the MSI client
client, err := armmsi.NewUserAssignedIdentitiesClient(azureSubscriptionID, defaultAzureCred, nil)
o.Expect(err).NotTo(o.HaveOccurred(), "Failed to create MSI client")
// Configure the managed identity
identity := armmsi.Identity{
Location: ®ion,
}
// Create the identity
result, err := client.CreateOrUpdate(context.Background(), resourceGroup, lokiStackName, identity, nil)
o.Expect(err).NotTo(o.HaveOccurred(), "Failed to create or update the identity")
return *result.Properties.ClientID, *result.Properties.PrincipalID
}
// Function to create Federated Credentials on Azure
func createFederatedCredentialforLoki(defaultAzureCred *azidentity.DefaultAzureCredential, azureSubscriptionID, managedIdentityName, lokiServiceAccount, lokiStackNS, federatedCredentialName, serviceAccountIssuer, resourceGroup string) {
subjectName := "system:serviceaccount:" + lokiStackNS + ":" + lokiServiceAccount
// Create the Federated Identity Credentials client
client, err := armmsi.NewFederatedIdentityCredentialsClient(azureSubscriptionID, defaultAzureCred, nil)
o.Expect(err).NotTo(o.HaveOccurred(), "Failed to create federated identity credentials client")
// Create or update the federated identity credential
result, err := client.CreateOrUpdate(
context.Background(),
resourceGroup,
managedIdentityName,
federatedCredentialName,
armmsi.FederatedIdentityCredential{
Properties: &armmsi.FederatedIdentityCredentialProperties{
Issuer: &serviceAccountIssuer,
Subject: &subjectName,
Audiences: []*string{azTo.Ptr("api://AzureADTokenExchange")},
},
},
nil,
)
o.Expect(err).NotTo(o.HaveOccurred(), "Failed to create or update the federated credential: "+federatedCredentialName)
e2e.Logf("Federated credential created/updated successfully: %s\n", *result.Name)
}
// Assigns role to a Azure Managed Identity on subscription level scope
func createRoleAssignmentForManagedIdentity(defaultAzureCred *azidentity.DefaultAzureCredential, azureSubscriptionID, identityPrincipalID string) {
clientFactory, err := armauthorization.NewClientFactory(azureSubscriptionID, defaultAzureCred, nil)
o.Expect(err).NotTo(o.HaveOccurred(), "Failed to create instance of ClientFactory")
scope := "/subscriptions/" + azureSubscriptionID
// Below is standard role definition ID for Storage Blob Data Contributor built-in role
roleDefinitionID := scope + "/providers/Microsoft.Authorization/roleDefinitions/ba92f5b4-2d11-453d-a403-e96b0029c9fe"
// Create or update a role assignment by scope and name
_, err = clientFactory.NewRoleAssignmentsClient().Create(context.Background(), scope, uuid.NewString(), armauthorization.RoleAssignmentCreateParameters{
Properties: &armauthorization.RoleAssignmentProperties{
PrincipalID: azTo.Ptr(identityPrincipalID),
PrincipalType: azTo.Ptr(armauthorization.PrincipalTypeServicePrincipal),
RoleDefinitionID: azTo.Ptr(roleDefinitionID),
},
}, nil)
o.Expect(err).NotTo(o.HaveOccurred(), "Role Assignment operation failure....")
}
// Creates Azure storage account
func createStorageAccountOnAzure(defaultAzureCred *azidentity.DefaultAzureCredential, azureSubscriptionID, resourceGroup, region string) string {
storageAccountName := "aosqelogging" + getRandomString()
// Create the storage account
storageClient, err := armstorage.NewAccountsClient(azureSubscriptionID, defaultAzureCred, nil)
o.Expect(err).NotTo(o.HaveOccurred())
result, err := storageClient.BeginCreate(context.Background(), resourceGroup, storageAccountName, armstorage.AccountCreateParameters{
Location: azTo.Ptr(region),
SKU: &armstorage.SKU{
Name: azTo.Ptr(armstorage.SKUNameStandardLRS),
},
Kind: azTo.Ptr(armstorage.KindStorageV2),
}, nil)
o.Expect(err).NotTo(o.HaveOccurred())
// Poll until the Storage account is ready
_, err = result.PollUntilDone(context.Background(), &azRuntime.PollUntilDoneOptions{
Frequency: 10 * time.Second,
})
o.Expect(err).NotTo(o.HaveOccurred(), "Storage account is not ready...")
os.Setenv("LOKI_OBJECT_STORAGE_STORAGE_ACCOUNT", storageAccountName)
return storageAccountName
}
// Returns the Azure environment and storage account URI suffixes
func getStorageAccountURISuffixAndEnvForAzure(oc *exutil.CLI) (string, string) {
// To return account URI suffix and env
cloudName, _ := oc.AsAdmin().WithoutNamespace().Run("get").Args("infrastructure", "cluster", "-o=jsonpath={.status.platformStatus.azure.cloudName}").Output()
storageAccountURISuffix := ".blob.core.windows.net"
environment := "AzureGlobal"
// Currently we don't have template support for STS/WIF on Azure Government
// The below code should be ok to run when support is added for WIF
if strings.ToLower(cloudName) == "azureusgovernmentcloud" {
storageAccountURISuffix = ".blob.core.usgovcloudapi.net"
environment = "AzureUSGovernment"
}
if strings.ToLower(cloudName) == "azurechinacloud" {
storageAccountURISuffix = ".blob.core.chinacloudapi.cn"
environment = "AzureChinaCloud"
}
if strings.ToLower(cloudName) == "azuregermancloud" {
environment = "AzureGermanCloud"
storageAccountURISuffix = ".blob.core.cloudapi.de"
}
return environment, storageAccountURISuffix
}
// Creates a blob container under the provided storageAccount
func createBlobContaineronAzure(defaultAzureCred *azidentity.DefaultAzureCredential, storageAccountName, storageAccountURISuffix, containerName string) {
blobServiceClient, err := azblob.NewClient(fmt.Sprintf("https://%s%s", storageAccountName, storageAccountURISuffix), defaultAzureCred, nil)
o.Expect(err).NotTo(o.HaveOccurred())
_, err = blobServiceClient.CreateContainer(context.Background(), containerName, nil)
o.Expect(err).NotTo(o.HaveOccurred())
e2e.Logf("%s container created successfully: ", containerName)
}
// Creates Loki object storage secret required on Azure STS/WIF clusters
func createLokiObjectStorageSecretForWIF(oc *exutil.CLI, lokiStackNS, objectStorageSecretName, environment, containerName, storageAccountName string) error {
return oc.NotShowInfo().AsAdmin().WithoutNamespace().Run("create").Args("secret", "generic", "-n", lokiStackNS, objectStorageSecretName, "--from-literal=environment="+environment, "--from-literal=container="+containerName, "--from-literal=account_name="+storageAccountName).Execute()
}
// Deletes a storage account in Microsoft Azure
func deleteAzureStorageAccount(defaultAzureCred *azidentity.DefaultAzureCredential, azureSubscriptionID, resourceGroupName, storageAccountName string) {
clientFactory, err := armstorage.NewClientFactory(azureSubscriptionID, defaultAzureCred, nil)
o.Expect(err).NotTo(o.HaveOccurred(), "failed to create instance of ClientFactory for storage account deletion")
_, err = clientFactory.NewAccountsClient().Delete(context.Background(), resourceGroupName, storageAccountName, nil)
if err != nil {
e2e.Logf("Error while deleting storage account. " + err.Error())
} else {
e2e.Logf("storage account deleted successfully..")
}
}
// Deletes the Azure Managed identity
func deleteManagedIdentityOnAzure(defaultAzureCred *azidentity.DefaultAzureCredential, azureSubscriptionID, resourceGroupName, identityName string) {
client, err := armmsi.NewUserAssignedIdentitiesClient(azureSubscriptionID, defaultAzureCred, nil)
o.Expect(err).NotTo(o.HaveOccurred(), "failed to create MSI client for identity deletion")
_, err = client.Delete(context.Background(), resourceGroupName, identityName, nil)
if err != nil {
e2e.Logf("Error deleting identity. " + err.Error())
} else {
e2e.Logf("managed identity deleted successfully...")
}
}
// patches CLIENT_ID, SUBSCRIPTION_ID, TENANT_ID AND REGION into Loki subscription on Azure WIF clusters
func patchLokiConfigIntoLokiSubscription(oc *exutil.CLI, azureSubscriptionID, identityClientID, region string) {
patchConfig := `{
"spec": {
"config": {
"env": [
{
"name": "CLIENTID",
"value": "%s"
},
{
"name": "TENANTID",
"value": "%s"
},
{
"name": "SUBSCRIPTIONID",
"value": "%s"
},
{
"name": "REGION",
"value": "%s"
}
]
}
}
}`
err := oc.NotShowInfo().AsAdmin().WithoutNamespace().Run("patch").Args("sub", "loki-operator", "-n", "openshift-operators-redhat", "-p", fmt.Sprintf(patchConfig, identityClientID, os.Getenv("AZURE_TENANT_ID"), azureSubscriptionID, region), "--type=merge").Execute()
o.Expect(err).NotTo(o.HaveOccurred(), "Patching Loki Operator failed...")
WaitForPodsReadyWithLabel(oc, "openshift-operators-redhat", "name=loki-operator-controller-manager")
}
// Performs creation of Managed Identity, Associated Federated credentials, Role assignment to the managed identity and object storage creation on Azure
func performManagedIdentityAndSecretSetupForAzureWIF(oc *exutil.CLI, lokistackName, lokiStackNS, azureContainerName, lokiStackStorageSecretName string) {
region, err := getAzureClusterRegion(oc)
o.Expect(err).NotTo(o.HaveOccurred())
serviceAccountIssuer, err := oc.AsAdmin().WithoutNamespace().Run("get").Args("authentication.config", "cluster", "-o=jsonpath={.spec.serviceAccountIssuer}").Output()
o.Expect(err).NotTo(o.HaveOccurred())
resourceGroup, err := getResourceGroupOnAzure(oc)
o.Expect(err).NotTo(o.HaveOccurred())
azureSubscriptionID := os.Getenv("AZURE_SUBSCRIPTION_ID")
cred := createNewDefaultAzureCredential()
identityClientID, identityPrincipalID := createManagedIdentityOnAzure(cred, azureSubscriptionID, lokistackName, resourceGroup, region)
createFederatedCredentialforLoki(cred, azureSubscriptionID, lokistackName, lokistackName, lokiStackNS, "openshift-logging-"+lokistackName, serviceAccountIssuer, resourceGroup)
createFederatedCredentialforLoki(cred, azureSubscriptionID, lokistackName, lokistackName+"-ruler", lokiStackNS, "openshift-logging-"+lokistackName+"-ruler", serviceAccountIssuer, resourceGroup)
createRoleAssignmentForManagedIdentity(cred, azureSubscriptionID, identityPrincipalID)
patchLokiConfigIntoLokiSubscription(oc, azureSubscriptionID, identityClientID, region)
storageAccountName := createStorageAccountOnAzure(cred, azureSubscriptionID, resourceGroup, region)
environment, storageAccountURISuffix := getStorageAccountURISuffixAndEnvForAzure(oc)
createBlobContaineronAzure(cred, storageAccountName, storageAccountURISuffix, azureContainerName)
err = createLokiObjectStorageSecretForWIF(oc, lokiStackNS, lokiStackStorageSecretName, environment, azureContainerName, storageAccountName)
o.Expect(err).NotTo(o.HaveOccurred())
}
// Function to check if tenant logs are present under the Azure blob Container.
// Use getStorageAccountURISuffixAndEnvForAzure() to get the storage account URI suffix.
// Returns success if any one of the tenants under tenants[] are found.
func validatesIfLogsArePushedToAzureContainer(storageAccountURISuffix, storageAccountName, containerName string, tenants []string) {
cred := createNewDefaultAzureCredential()
// Create a new Blob service client
serviceClient, err := azblob.NewClient("https://"+storageAccountName+storageAccountURISuffix, cred, nil)
o.Expect(err).NotTo(o.HaveOccurred(), "failed to create service client..")
// Poll to check log streams are flushed to container referenced under loki object storage secret
err = wait.PollUntilContextTimeout(context.Background(), 30*time.Second, 300*time.Second, true, func(context.Context) (done bool, err error) {
// Create a client to interact with the container and List blobs in the container
pager := serviceClient.NewListBlobsFlatPager(containerName, nil)
for pager.More() {
// advance to the next page
page, err := pager.NextPage(context.TODO())
o.Expect(err).NotTo(o.HaveOccurred())
// check the blob names for this page
for _, blob := range page.Segment.BlobItems {
for _, tenantName := range tenants {
if strings.Contains(*blob.Name, tenantName) {
e2e.Logf("Logs " + *blob.Name + " found under the container: " + containerName)
return true, nil
}
}
}
}
e2e.Logf("Waiting for data to be available under container: " + containerName)
return false, nil
})
exutil.AssertWaitPollNoErr(err, "Timed out...No data is available under the container: "+containerName)
}
func getResourceGroupOnAzure(oc *exutil.CLI) (string, error) {
resourceGroup, err := oc.AsAdmin().WithoutNamespace().Run("get").Args("infrastructures", "cluster", "-o=jsonpath={.status.platformStatus.azure.resourceGroupName}").Output()
return resourceGroup, err
}
// Get region/location of cluster running on Azure Cloud
func getAzureClusterRegion(oc *exutil.CLI) (string, error) {
return oc.AsAdmin().WithoutNamespace().Run("get").Args("node", `-ojsonpath={.items[].metadata.labels.topology\.kubernetes\.io/region}`).Output()
}
|
package netobserv
| ||||
function
|
openshift/openshift-tests-private
|
9127070c-6f2d-435d-b84f-83ea365fc5fc
|
createNewDefaultAzureCredential
|
['azTo "github.com/Azure/azure-sdk-for-go/sdk/azcore/to"', '"github.com/Azure/azure-sdk-for-go/sdk/azidentity"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/azure_utils.go
|
func createNewDefaultAzureCredential() *azidentity.DefaultAzureCredential {
cred, err := azidentity.NewDefaultAzureCredential(nil)
o.Expect(err).NotTo(o.HaveOccurred(), "Failed to obtain a credential")
return cred
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
1d16602c-c5c2-4613-bc61-3fcc6a793c61
|
createManagedIdentityOnAzure
|
['"context"', 'azTo "github.com/Azure/azure-sdk-for-go/sdk/azcore/to"', '"github.com/Azure/azure-sdk-for-go/sdk/azidentity"', '"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/msi/armmsi"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/azure_utils.go
|
func createManagedIdentityOnAzure(defaultAzureCred *azidentity.DefaultAzureCredential, azureSubscriptionID, lokiStackName, resourceGroup, region string) (string, string) {
// Create the MSI client
client, err := armmsi.NewUserAssignedIdentitiesClient(azureSubscriptionID, defaultAzureCred, nil)
o.Expect(err).NotTo(o.HaveOccurred(), "Failed to create MSI client")
// Configure the managed identity
identity := armmsi.Identity{
Location: ®ion,
}
// Create the identity
result, err := client.CreateOrUpdate(context.Background(), resourceGroup, lokiStackName, identity, nil)
o.Expect(err).NotTo(o.HaveOccurred(), "Failed to create or update the identity")
return *result.Properties.ClientID, *result.Properties.PrincipalID
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
a50d68c2-6079-4a7d-abc4-91d51c7c8f69
|
createFederatedCredentialforLoki
|
['"context"', 'azTo "github.com/Azure/azure-sdk-for-go/sdk/azcore/to"', '"github.com/Azure/azure-sdk-for-go/sdk/azidentity"', '"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/msi/armmsi"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/azure_utils.go
|
func createFederatedCredentialforLoki(defaultAzureCred *azidentity.DefaultAzureCredential, azureSubscriptionID, managedIdentityName, lokiServiceAccount, lokiStackNS, federatedCredentialName, serviceAccountIssuer, resourceGroup string) {
subjectName := "system:serviceaccount:" + lokiStackNS + ":" + lokiServiceAccount
// Create the Federated Identity Credentials client
client, err := armmsi.NewFederatedIdentityCredentialsClient(azureSubscriptionID, defaultAzureCred, nil)
o.Expect(err).NotTo(o.HaveOccurred(), "Failed to create federated identity credentials client")
// Create or update the federated identity credential
result, err := client.CreateOrUpdate(
context.Background(),
resourceGroup,
managedIdentityName,
federatedCredentialName,
armmsi.FederatedIdentityCredential{
Properties: &armmsi.FederatedIdentityCredentialProperties{
Issuer: &serviceAccountIssuer,
Subject: &subjectName,
Audiences: []*string{azTo.Ptr("api://AzureADTokenExchange")},
},
},
nil,
)
o.Expect(err).NotTo(o.HaveOccurred(), "Failed to create or update the federated credential: "+federatedCredentialName)
e2e.Logf("Federated credential created/updated successfully: %s\n", *result.Name)
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
7a1cc929-1b79-4a4d-9888-56cbf8fc5cb6
|
createRoleAssignmentForManagedIdentity
|
['"context"', 'azTo "github.com/Azure/azure-sdk-for-go/sdk/azcore/to"', '"github.com/Azure/azure-sdk-for-go/sdk/azidentity"', '"github.com/google/uuid"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/azure_utils.go
|
func createRoleAssignmentForManagedIdentity(defaultAzureCred *azidentity.DefaultAzureCredential, azureSubscriptionID, identityPrincipalID string) {
clientFactory, err := armauthorization.NewClientFactory(azureSubscriptionID, defaultAzureCred, nil)
o.Expect(err).NotTo(o.HaveOccurred(), "Failed to create instance of ClientFactory")
scope := "/subscriptions/" + azureSubscriptionID
// Below is standard role definition ID for Storage Blob Data Contributor built-in role
roleDefinitionID := scope + "/providers/Microsoft.Authorization/roleDefinitions/ba92f5b4-2d11-453d-a403-e96b0029c9fe"
// Create or update a role assignment by scope and name
_, err = clientFactory.NewRoleAssignmentsClient().Create(context.Background(), scope, uuid.NewString(), armauthorization.RoleAssignmentCreateParameters{
Properties: &armauthorization.RoleAssignmentProperties{
PrincipalID: azTo.Ptr(identityPrincipalID),
PrincipalType: azTo.Ptr(armauthorization.PrincipalTypeServicePrincipal),
RoleDefinitionID: azTo.Ptr(roleDefinitionID),
},
}, nil)
o.Expect(err).NotTo(o.HaveOccurred(), "Role Assignment operation failure....")
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
68749b4a-444e-4ca2-a676-0ad39d053fea
|
createStorageAccountOnAzure
|
['"context"', '"os"', '"time"', '"github.com/Azure/azure-sdk-for-go/sdk/azidentity"', '"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/azure_utils.go
|
func createStorageAccountOnAzure(defaultAzureCred *azidentity.DefaultAzureCredential, azureSubscriptionID, resourceGroup, region string) string {
storageAccountName := "aosqelogging" + getRandomString()
// Create the storage account
storageClient, err := armstorage.NewAccountsClient(azureSubscriptionID, defaultAzureCred, nil)
o.Expect(err).NotTo(o.HaveOccurred())
result, err := storageClient.BeginCreate(context.Background(), resourceGroup, storageAccountName, armstorage.AccountCreateParameters{
Location: azTo.Ptr(region),
SKU: &armstorage.SKU{
Name: azTo.Ptr(armstorage.SKUNameStandardLRS),
},
Kind: azTo.Ptr(armstorage.KindStorageV2),
}, nil)
o.Expect(err).NotTo(o.HaveOccurred())
// Poll until the Storage account is ready
_, err = result.PollUntilDone(context.Background(), &azRuntime.PollUntilDoneOptions{
Frequency: 10 * time.Second,
})
o.Expect(err).NotTo(o.HaveOccurred(), "Storage account is not ready...")
os.Setenv("LOKI_OBJECT_STORAGE_STORAGE_ACCOUNT", storageAccountName)
return storageAccountName
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
e66a33c1-2ae7-4159-87a1-96692dc304d1
|
getStorageAccountURISuffixAndEnvForAzure
|
['"strings"', 'azTo "github.com/Azure/azure-sdk-for-go/sdk/azcore/to"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/azure_utils.go
|
func getStorageAccountURISuffixAndEnvForAzure(oc *exutil.CLI) (string, string) {
// To return account URI suffix and env
cloudName, _ := oc.AsAdmin().WithoutNamespace().Run("get").Args("infrastructure", "cluster", "-o=jsonpath={.status.platformStatus.azure.cloudName}").Output()
storageAccountURISuffix := ".blob.core.windows.net"
environment := "AzureGlobal"
// Currently we don't have template support for STS/WIF on Azure Government
// The below code should be ok to run when support is added for WIF
if strings.ToLower(cloudName) == "azureusgovernmentcloud" {
storageAccountURISuffix = ".blob.core.usgovcloudapi.net"
environment = "AzureUSGovernment"
}
if strings.ToLower(cloudName) == "azurechinacloud" {
storageAccountURISuffix = ".blob.core.chinacloudapi.cn"
environment = "AzureChinaCloud"
}
if strings.ToLower(cloudName) == "azuregermancloud" {
environment = "AzureGermanCloud"
storageAccountURISuffix = ".blob.core.cloudapi.de"
}
return environment, storageAccountURISuffix
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
571f1bbe-5bf6-4c6b-945b-ab8464db18e0
|
createBlobContaineronAzure
|
['"context"', '"fmt"', '"github.com/Azure/azure-sdk-for-go/sdk/azidentity"', '"github.com/Azure/azure-sdk-for-go/sdk/storage/azblob"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/azure_utils.go
|
func createBlobContaineronAzure(defaultAzureCred *azidentity.DefaultAzureCredential, storageAccountName, storageAccountURISuffix, containerName string) {
blobServiceClient, err := azblob.NewClient(fmt.Sprintf("https://%s%s", storageAccountName, storageAccountURISuffix), defaultAzureCred, nil)
o.Expect(err).NotTo(o.HaveOccurred())
_, err = blobServiceClient.CreateContainer(context.Background(), containerName, nil)
o.Expect(err).NotTo(o.HaveOccurred())
e2e.Logf("%s container created successfully: ", containerName)
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
64d27f26-ba54-4747-9bbb-d11132467418
|
createLokiObjectStorageSecretForWIF
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/azure_utils.go
|
func createLokiObjectStorageSecretForWIF(oc *exutil.CLI, lokiStackNS, objectStorageSecretName, environment, containerName, storageAccountName string) error {
return oc.NotShowInfo().AsAdmin().WithoutNamespace().Run("create").Args("secret", "generic", "-n", lokiStackNS, objectStorageSecretName, "--from-literal=environment="+environment, "--from-literal=container="+containerName, "--from-literal=account_name="+storageAccountName).Execute()
}
|
netobserv
| |||||
function
|
openshift/openshift-tests-private
|
0d43a4b8-6828-4be7-912d-7321a95a327c
|
deleteAzureStorageAccount
|
['"context"', 'azTo "github.com/Azure/azure-sdk-for-go/sdk/azcore/to"', '"github.com/Azure/azure-sdk-for-go/sdk/azidentity"', '"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/azure_utils.go
|
func deleteAzureStorageAccount(defaultAzureCred *azidentity.DefaultAzureCredential, azureSubscriptionID, resourceGroupName, storageAccountName string) {
clientFactory, err := armstorage.NewClientFactory(azureSubscriptionID, defaultAzureCred, nil)
o.Expect(err).NotTo(o.HaveOccurred(), "failed to create instance of ClientFactory for storage account deletion")
_, err = clientFactory.NewAccountsClient().Delete(context.Background(), resourceGroupName, storageAccountName, nil)
if err != nil {
e2e.Logf("Error while deleting storage account. " + err.Error())
} else {
e2e.Logf("storage account deleted successfully..")
}
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
78d9b382-c133-489a-9faa-a31bbf589736
|
deleteManagedIdentityOnAzure
|
['"context"', 'azTo "github.com/Azure/azure-sdk-for-go/sdk/azcore/to"', '"github.com/Azure/azure-sdk-for-go/sdk/azidentity"', '"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/msi/armmsi"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/azure_utils.go
|
func deleteManagedIdentityOnAzure(defaultAzureCred *azidentity.DefaultAzureCredential, azureSubscriptionID, resourceGroupName, identityName string) {
client, err := armmsi.NewUserAssignedIdentitiesClient(azureSubscriptionID, defaultAzureCred, nil)
o.Expect(err).NotTo(o.HaveOccurred(), "failed to create MSI client for identity deletion")
_, err = client.Delete(context.Background(), resourceGroupName, identityName, nil)
if err != nil {
e2e.Logf("Error deleting identity. " + err.Error())
} else {
e2e.Logf("managed identity deleted successfully...")
}
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
7e20507f-fbb3-42b0-b81e-902a89eb465c
|
patchLokiConfigIntoLokiSubscription
|
['"fmt"', '"os"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/azure_utils.go
|
func patchLokiConfigIntoLokiSubscription(oc *exutil.CLI, azureSubscriptionID, identityClientID, region string) {
patchConfig := `{
"spec": {
"config": {
"env": [
{
"name": "CLIENTID",
"value": "%s"
},
{
"name": "TENANTID",
"value": "%s"
},
{
"name": "SUBSCRIPTIONID",
"value": "%s"
},
{
"name": "REGION",
"value": "%s"
}
]
}
}
}`
err := oc.NotShowInfo().AsAdmin().WithoutNamespace().Run("patch").Args("sub", "loki-operator", "-n", "openshift-operators-redhat", "-p", fmt.Sprintf(patchConfig, identityClientID, os.Getenv("AZURE_TENANT_ID"), azureSubscriptionID, region), "--type=merge").Execute()
o.Expect(err).NotTo(o.HaveOccurred(), "Patching Loki Operator failed...")
WaitForPodsReadyWithLabel(oc, "openshift-operators-redhat", "name=loki-operator-controller-manager")
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
ed2a33d8-715a-41a2-8cd6-35afa9c39157
|
performManagedIdentityAndSecretSetupForAzureWIF
|
['"os"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/azure_utils.go
|
func performManagedIdentityAndSecretSetupForAzureWIF(oc *exutil.CLI, lokistackName, lokiStackNS, azureContainerName, lokiStackStorageSecretName string) {
region, err := getAzureClusterRegion(oc)
o.Expect(err).NotTo(o.HaveOccurred())
serviceAccountIssuer, err := oc.AsAdmin().WithoutNamespace().Run("get").Args("authentication.config", "cluster", "-o=jsonpath={.spec.serviceAccountIssuer}").Output()
o.Expect(err).NotTo(o.HaveOccurred())
resourceGroup, err := getResourceGroupOnAzure(oc)
o.Expect(err).NotTo(o.HaveOccurred())
azureSubscriptionID := os.Getenv("AZURE_SUBSCRIPTION_ID")
cred := createNewDefaultAzureCredential()
identityClientID, identityPrincipalID := createManagedIdentityOnAzure(cred, azureSubscriptionID, lokistackName, resourceGroup, region)
createFederatedCredentialforLoki(cred, azureSubscriptionID, lokistackName, lokistackName, lokiStackNS, "openshift-logging-"+lokistackName, serviceAccountIssuer, resourceGroup)
createFederatedCredentialforLoki(cred, azureSubscriptionID, lokistackName, lokistackName+"-ruler", lokiStackNS, "openshift-logging-"+lokistackName+"-ruler", serviceAccountIssuer, resourceGroup)
createRoleAssignmentForManagedIdentity(cred, azureSubscriptionID, identityPrincipalID)
patchLokiConfigIntoLokiSubscription(oc, azureSubscriptionID, identityClientID, region)
storageAccountName := createStorageAccountOnAzure(cred, azureSubscriptionID, resourceGroup, region)
environment, storageAccountURISuffix := getStorageAccountURISuffixAndEnvForAzure(oc)
createBlobContaineronAzure(cred, storageAccountName, storageAccountURISuffix, azureContainerName)
err = createLokiObjectStorageSecretForWIF(oc, lokiStackNS, lokiStackStorageSecretName, environment, azureContainerName, storageAccountName)
o.Expect(err).NotTo(o.HaveOccurred())
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
e9384f94-50a6-486f-ae22-cd595a6589fc
|
validatesIfLogsArePushedToAzureContainer
|
['"context"', '"strings"', '"time"', 'azTo "github.com/Azure/azure-sdk-for-go/sdk/azcore/to"', '"github.com/Azure/azure-sdk-for-go/sdk/storage/azblob"', '"k8s.io/apimachinery/pkg/util/wait"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/azure_utils.go
|
func validatesIfLogsArePushedToAzureContainer(storageAccountURISuffix, storageAccountName, containerName string, tenants []string) {
cred := createNewDefaultAzureCredential()
// Create a new Blob service client
serviceClient, err := azblob.NewClient("https://"+storageAccountName+storageAccountURISuffix, cred, nil)
o.Expect(err).NotTo(o.HaveOccurred(), "failed to create service client..")
// Poll to check log streams are flushed to container referenced under loki object storage secret
err = wait.PollUntilContextTimeout(context.Background(), 30*time.Second, 300*time.Second, true, func(context.Context) (done bool, err error) {
// Create a client to interact with the container and List blobs in the container
pager := serviceClient.NewListBlobsFlatPager(containerName, nil)
for pager.More() {
// advance to the next page
page, err := pager.NextPage(context.TODO())
o.Expect(err).NotTo(o.HaveOccurred())
// check the blob names for this page
for _, blob := range page.Segment.BlobItems {
for _, tenantName := range tenants {
if strings.Contains(*blob.Name, tenantName) {
e2e.Logf("Logs " + *blob.Name + " found under the container: " + containerName)
return true, nil
}
}
}
}
e2e.Logf("Waiting for data to be available under container: " + containerName)
return false, nil
})
exutil.AssertWaitPollNoErr(err, "Timed out...No data is available under the container: "+containerName)
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
0eab1341-f09b-4a42-b761-9e16a0222309
|
getResourceGroupOnAzure
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/azure_utils.go
|
func getResourceGroupOnAzure(oc *exutil.CLI) (string, error) {
resourceGroup, err := oc.AsAdmin().WithoutNamespace().Run("get").Args("infrastructures", "cluster", "-o=jsonpath={.status.platformStatus.azure.resourceGroupName}").Output()
return resourceGroup, err
}
|
netobserv
| |||||
function
|
openshift/openshift-tests-private
|
c4b7911a-3e65-4c18-8e54-17bc18df889b
|
getAzureClusterRegion
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/azure_utils.go
|
func getAzureClusterRegion(oc *exutil.CLI) (string, error) {
return oc.AsAdmin().WithoutNamespace().Run("get").Args("node", `-ojsonpath={.items[].metadata.labels.topology\.kubernetes\.io/region}`).Output()
}
|
netobserv
| |||||
file
|
openshift/openshift-tests-private
|
79d7d99b-c7df-4442-9893-4f84f9408f86
|
flowcollector
|
import (
"context"
"fmt"
"reflect"
"time"
exutil "github.com/openshift/openshift-tests-private/test/extended/util"
"k8s.io/apimachinery/pkg/util/wait"
e2e "k8s.io/kubernetes/test/e2e/framework"
)
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/flowcollector.go
|
package netobserv
import (
"context"
"fmt"
"reflect"
"time"
exutil "github.com/openshift/openshift-tests-private/test/extended/util"
"k8s.io/apimachinery/pkg/util/wait"
e2e "k8s.io/kubernetes/test/e2e/framework"
)
// Flowcollector struct to handle Flowcollector resources
type Flowcollector struct {
Namespace string
ProcessorKind string
MultiClusterDeployment string
AddZone string
LogType string
DeploymentModel string
LokiEnable string
LokiMode string
LokiURL string
LokiTLSCertName string
LokiStatusTLSEnable string
LokiStatusURL string
LokiStatusTLSCertName string
LokiStatusTLSUserCertName string
LokiNamespace string
MonolithicLokiURL string
KafkaAddress string
KafkaTLSEnable string
KafkaClusterName string
KafkaTopic string
KafkaUser string
KafkaNamespace string
FLPMetricServerTLSType string
EBPFMetricServerTLSType string
EBPFCacheActiveTimeout string
EBPFPrivileged string
Sampling string
EBPFMetrics string
EBPFeatures []string
CacheMaxFlows string
PacketDropEnable string
DNStrackingEnable string
PluginEnable string
NetworkPolicyEnable string
NetworkPolicyAdditionalNamespaces []string
Exporters []string
SecondayNetworks []string
Template string
}
type Flowlog struct {
// Source
SrcPort int
SrcK8S_Type string
SrcK8S_Name string
SrcK8S_HostName string
SrcK8S_OwnerType string
SrcAddr string
SrcMac string
// Destination
DstPort int
DstK8S_Type string
DstK8S_Name string
DstK8S_HostName string
DstK8S_OwnerType string
DstAddr string
DstMac string
DstK8S_HostIP string
// Protocol
Proto int
IcmpCode int
IcmpType int
Dscp int
Flags []string
// Time
TimeReceived int
TimeFlowEndMs int
TimeFlowStartMs int
// Interface
IfDirection int
IfDirections []int
Interfaces []string
Etype int
// Others
Packets int
Bytes int
Duplicate bool
AgentIP string
HashId string `json:"_HashId,omitempty"`
IsFirst bool `json:"_IsFirst,omitempty"`
RecordType string `json:"_RecordType,omitempty"`
NumFlowLogs int `json:"numFlowLogs,omitempty"`
K8S_ClusterName string `json:"K8S_ClusterName,omitempty"`
// Zone
SrcK8S_Zone string `json:"SrcK8S_Zone,omitempty"`
DstK8S_Zone string `json:"DstK8S_Zone,omitempty"`
// DNS
DnsLatencyMs int `json:"DnsLatencyMs,omitempty"`
DnsFlagsResponseCode string `json:"DnsFlagsResponseCode,omitempty"`
// Packet Drop
PktDropBytes int `json:"PktDropBytes,omitempty"`
PktDropPackets int `json:"PktDropPackets,omitempty"`
PktDropLatestState string `json:"PktDropLatestState,omitempty"`
PktDropLatestDropCause string `json:"PktDropLatestDropCause,omitempty"`
// RTT
TimeFlowRttNs int `json:"TimeFlowRttNs,omitempty"`
// Packet Translation
XlatDstAddr string `json:"XlatDstAddr,omitempty"`
XlatDstK8S_Name string `json:"XlatDstK8S_Name,omitempty"`
XlatDstK8S_Namespace string `json:"XlatDstK8S_Namespace,omitempty"`
XlatDstK8S_Type string `json:"XlatDstK8S_Type,omitempty"`
XlatDstPort int `json:"XlatDstPort,omitempty"`
XlatSrcAddr string `json:"XlatSrcAddr,omitempty"`
XlatSrcK8S_Name string `json:"XlatSrcK8S_Name,omitempty"`
XlatSrcK8S_Namespace string `json:"XlatSrcK8S_Namespace,omitempty"`
ZoneId int `json:"ZoneId,omitempty"`
// Network Events
NetworkEvents []NetworkEvent `json:"NetworkEvents,omitempty"`
// Secondary Network
SrcK8S_NetworkName string `json:"SrcK8S_NetworkName,omitempty"`
DstK8S_NetworkName string `json:"DstK8S_NetworkName,omitempty"`
// UDN
Udns []string `json:"Udns,omitempty"`
}
type NetworkEvent struct {
Action string `json:"Action,omitempty"`
Type string `json:"Type,omitempty"`
Name string `json:"Name,omitempty"`
Namespace string `json:"Namespace,omitempty"`
Direction string `json:"Direction,omitempty"`
Feature string `json:"Feature,omitempty"`
}
type FlowRecord struct {
Timestamp int64
Flowlog Flowlog
}
type Lokilabels struct {
App string
SrcK8S_Namespace string
DstK8S_Namespace string
RecordType string
FlowDirection string
SrcK8S_OwnerName string
DstK8S_OwnerName string
K8S_ClusterName string
SrcK8S_Type string
DstK8S_Type string
Interfaces string
}
// create flowcollector CRD for a given manifest file
func (flow Flowcollector) CreateFlowcollector(oc *exutil.CLI) {
parameters := []string{"--ignore-unknown-parameters=true", "-f", flow.Template, "-p"}
flowCollector := reflect.ValueOf(&flow).Elem()
for i := 0; i < flowCollector.NumField(); i++ {
if flowCollector.Field(i).Interface() != "" {
if flowCollector.Type().Field(i).Name != "Template" {
parameters = append(parameters, fmt.Sprintf("%s=%s", flowCollector.Type().Field(i).Name, flowCollector.Field(i).Interface()))
}
}
}
exutil.ApplyNsResourceFromTemplate(oc, flow.Namespace, parameters...)
flow.WaitForFlowcollectorReady(oc)
}
// delete flowcollector CRD from a cluster
func (flow *Flowcollector) DeleteFlowcollector(oc *exutil.CLI) error {
return oc.AsAdmin().WithoutNamespace().Run("delete").Args("flowcollector", "cluster").Execute()
}
func (flow *Flowcollector) WaitForFlowcollectorReady(oc *exutil.CLI) {
// check FLP status
if flow.DeploymentModel == "Kafka" {
waitUntilDeploymentReady(oc, "flowlogs-pipeline-transformer", flow.Namespace)
} else {
waitUntilDaemonSetReady(oc, "flowlogs-pipeline", flow.Namespace)
}
// check ebpf-agent status
waitUntilDaemonSetReady(oc, "netobserv-ebpf-agent", flow.Namespace+"-privileged")
// check plugin status
if flow.PluginEnable != "false" {
waitUntilDeploymentReady(oc, "netobserv-plugin", flow.Namespace)
}
exutil.AssertAllPodsToBeReady(oc, flow.Namespace)
exutil.AssertAllPodsToBeReady(oc, flow.Namespace+"-privileged")
err := wait.PollUntilContextTimeout(context.Background(), 10*time.Second, 600*time.Second, false, func(context.Context) (done bool, err error) {
status, err := oc.AsAdmin().Run("get").Args("flowcollector", "-o", "jsonpath='{.items[*].status.conditions[0].reason}'").Output()
if err != nil {
return false, err
}
if status == "'Ready'" {
return true, nil
}
msg, err := oc.AsAdmin().Run("get").Args("flowcollector", "-o", "jsonpath='{.items[*].status.conditions[0].message}'").Output()
e2e.Logf("flowcollector status is %s due to %s", status, msg)
if err != nil {
return false, err
}
return false, nil
})
exutil.AssertWaitPollNoErr(err, "Flowcollector did not become Ready")
}
|
package netobserv
| ||||
function
|
openshift/openshift-tests-private
|
e3fb0109-142f-4e0a-95a3-51620852d28a
|
CreateFlowcollector
|
['"fmt"', '"reflect"']
|
['Flowcollector']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/flowcollector.go
|
func (flow Flowcollector) CreateFlowcollector(oc *exutil.CLI) {
parameters := []string{"--ignore-unknown-parameters=true", "-f", flow.Template, "-p"}
flowCollector := reflect.ValueOf(&flow).Elem()
for i := 0; i < flowCollector.NumField(); i++ {
if flowCollector.Field(i).Interface() != "" {
if flowCollector.Type().Field(i).Name != "Template" {
parameters = append(parameters, fmt.Sprintf("%s=%s", flowCollector.Type().Field(i).Name, flowCollector.Field(i).Interface()))
}
}
}
exutil.ApplyNsResourceFromTemplate(oc, flow.Namespace, parameters...)
flow.WaitForFlowcollectorReady(oc)
}
|
netobserv
| |||
function
|
openshift/openshift-tests-private
|
dbf21ed6-21cb-4380-8d76-8c8a7280914f
|
DeleteFlowcollector
|
['Flowcollector']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/flowcollector.go
|
func (flow *Flowcollector) DeleteFlowcollector(oc *exutil.CLI) error {
return oc.AsAdmin().WithoutNamespace().Run("delete").Args("flowcollector", "cluster").Execute()
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
197c64c3-aaa4-4954-92d7-aaaa356618a3
|
WaitForFlowcollectorReady
|
['"context"', '"time"', '"k8s.io/apimachinery/pkg/util/wait"']
|
['Flowcollector']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/flowcollector.go
|
func (flow *Flowcollector) WaitForFlowcollectorReady(oc *exutil.CLI) {
// check FLP status
if flow.DeploymentModel == "Kafka" {
waitUntilDeploymentReady(oc, "flowlogs-pipeline-transformer", flow.Namespace)
} else {
waitUntilDaemonSetReady(oc, "flowlogs-pipeline", flow.Namespace)
}
// check ebpf-agent status
waitUntilDaemonSetReady(oc, "netobserv-ebpf-agent", flow.Namespace+"-privileged")
// check plugin status
if flow.PluginEnable != "false" {
waitUntilDeploymentReady(oc, "netobserv-plugin", flow.Namespace)
}
exutil.AssertAllPodsToBeReady(oc, flow.Namespace)
exutil.AssertAllPodsToBeReady(oc, flow.Namespace+"-privileged")
err := wait.PollUntilContextTimeout(context.Background(), 10*time.Second, 600*time.Second, false, func(context.Context) (done bool, err error) {
status, err := oc.AsAdmin().Run("get").Args("flowcollector", "-o", "jsonpath='{.items[*].status.conditions[0].reason}'").Output()
if err != nil {
return false, err
}
if status == "'Ready'" {
return true, nil
}
msg, err := oc.AsAdmin().Run("get").Args("flowcollector", "-o", "jsonpath='{.items[*].status.conditions[0].message}'").Output()
e2e.Logf("flowcollector status is %s due to %s", status, msg)
if err != nil {
return false, err
}
return false, nil
})
exutil.AssertWaitPollNoErr(err, "Flowcollector did not become Ready")
}
|
netobserv
| |||
file
|
openshift/openshift-tests-private
|
041a261c-0ded-4042-beb0-a46490a643da
|
flowcollector_utils
|
import (
"context"
"encoding/json"
"fmt"
"math"
"reflect"
"regexp"
"strconv"
"strings"
"time"
o "github.com/onsi/gomega"
exutil "github.com/openshift/openshift-tests-private/test/extended/util"
"k8s.io/apimachinery/pkg/util/wait"
e2e "k8s.io/kubernetes/test/e2e/framework"
)
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/flowcollector_utils.go
|
package netobserv
import (
"context"
"encoding/json"
"fmt"
"math"
"reflect"
"regexp"
"strconv"
"strings"
"time"
o "github.com/onsi/gomega"
exutil "github.com/openshift/openshift-tests-private/test/extended/util"
"k8s.io/apimachinery/pkg/util/wait"
e2e "k8s.io/kubernetes/test/e2e/framework"
)
// returns ture/false if flowcollector API exists.
func isFlowCollectorAPIExists(oc *exutil.CLI) (bool, error) {
stdout, err := oc.AsAdmin().WithoutNamespace().Run("get").Args("crd", "-o", "jsonpath='{.items[*].spec.names.kind}'").Output()
if err != nil {
return false, err
}
return strings.Contains(stdout, "FlowCollector"), nil
}
// Verify flow records from logs
func verifyFlowRecordFromLogs(podLog string) {
re := regexp.MustCompile("{\"AgentIP\":.*")
flowRecords := re.FindAllString(podLog, -3)
partialFlowRegex, err := regexp.Compile("DstMac\":\"00:00:00:00:00:00")
for _, flow := range flowRecords {
// skip assertions and log Partial flows
o.Expect(err).NotTo(o.HaveOccurred())
if partialFlowRegex.Match([]byte(flow)) {
e2e.Logf("Found partial flows %s", flow)
} else {
o.Expect(flow).Should(o.And(
o.MatchRegexp("Bytes.:[0-9]+"),
o.MatchRegexp("TimeFlowEndMs.:[1-9][0-9]+"),
o.MatchRegexp("TimeFlowStartMs.:[1-9][0-9]+"),
o.MatchRegexp("TimeReceived.:[1-9][0-9]+")), flow)
}
}
}
// Get flow recrods from loki
func getFlowRecords(lokiValues [][]string) ([]FlowRecord, error) {
flowRecords := []FlowRecord{}
for _, values := range lokiValues {
timestamp, _ := strconv.ParseInt(values[0], 10, 64)
var flowlog Flowlog
err := json.Unmarshal([]byte(values[1]), &flowlog)
if err != nil {
return []FlowRecord{}, err
}
flowRecord := FlowRecord{
Timestamp: timestamp,
Flowlog: flowlog,
}
flowRecords = append(flowRecords, flowRecord)
}
return flowRecords, nil
}
// Verify some key and deterministic flow recrods fields and their values
func (flowlog *Flowlog) verifyFlowRecord() {
flow := fmt.Sprintf("Flow log is: %+v\n", flowlog)
o.Expect(flowlog.AgentIP).To(o.Equal(flowlog.DstK8S_HostIP), flow)
o.Expect(flowlog.Bytes).Should(o.BeNumerically(">", 0), flow)
now := time.Now()
compareTime := now.Add(time.Duration(-2) * time.Hour)
compareTimeMs := compareTime.UnixMilli()
o.Expect(flowlog.TimeFlowEndMs).Should(o.BeNumerically(">", compareTimeMs), flow)
o.Expect(flowlog.TimeFlowStartMs).Should(o.BeNumerically(">", compareTimeMs), flow)
o.Expect(flowlog.TimeReceived).Should(o.BeNumerically(">", compareTime.Unix()), flow)
}
func (lokilabels Lokilabels) getLokiQueryLabels() string {
label := reflect.ValueOf(&lokilabels).Elem()
var lokiQuery = "{"
for i := 0; i < label.NumField(); i++ {
if label.Field(i).Interface() != "" {
switch labelName := label.Type().Field(i).Name; labelName {
case "App":
lokiQuery += fmt.Sprintf("%s=\"%s\", ", strings.ToLower(label.Type().Field(i).Name), label.Field(i).Interface())
case "RecordType":
lokiQuery += fmt.Sprintf("_%s=\"%s\", ", label.Type().Field(i).Name, label.Field(i).Interface())
case "FlowDirection":
if label.Field(i).Interface() == "0" || label.Field(i).Interface() == "1" || label.Field(i).Interface() == "2" {
lokiQuery += fmt.Sprintf("%s=\"%s\", ", label.Type().Field(i).Name, label.Field(i).Interface())
}
default:
lokiQuery += fmt.Sprintf("%s=\"%s\", ", label.Type().Field(i).Name, label.Field(i).Interface())
}
}
}
lokiQuery = strings.TrimSuffix(lokiQuery, ", ")
lokiQuery += "}"
return lokiQuery
}
func (lokilabels Lokilabels) getLokiJSONfilterQuery(parameters ...string) string {
lokiQuery := lokilabels.getLokiQueryLabels()
if len(parameters) != 0 {
lokiQuery += " | json"
for _, p := range parameters {
if strings.Contains(p, "Flags") {
lokiQuery += fmt.Sprintf(" %s | json", p)
} else {
lokiQuery += fmt.Sprintf(" | %s", p)
}
}
}
e2e.Logf("Loki query is %s", lokiQuery)
return lokiQuery
}
func (lokilabels Lokilabels) getLokiRegexFilterQuery(parameters ...string) string {
lokiQuery := lokilabels.getLokiQueryLabels()
if len(parameters) != 0 {
for _, p := range parameters {
lokiQuery += fmt.Sprintf(" |~ %s", p)
}
}
e2e.Logf("Loki query is %s", lokiQuery)
return lokiQuery
}
func (lokilabels Lokilabels) getLokiQuery(filterType string, parameters ...string) string {
var lokiQuery string
switch filterType {
case "JSON":
lokiQuery = lokilabels.getLokiJSONfilterQuery(parameters...)
case "REGEX":
lokiQuery = lokilabels.getLokiRegexFilterQuery(parameters...)
default:
panic("loki filter is not supported yet")
}
return lokiQuery
}
func (lokilabels Lokilabels) GetMonolithicLokiFlowLogs(lokiRoute string, startTime time.Time, parameters ...string) ([]FlowRecord, error) {
lc := newLokiClient(lokiRoute, startTime).retry(5)
lc.quiet = false
lc.localhost = true
lokiQuery := lokilabels.getLokiQuery("REGEX", parameters...)
flowRecords := []FlowRecord{}
var res *lokiQueryResponse
err := wait.PollUntilContextTimeout(context.Background(), 30*time.Second, 300*time.Second, false, func(context.Context) (done bool, err error) {
var qErr error
res, qErr = lc.searchLogsInLoki("", lokiQuery)
if qErr != nil {
e2e.Logf("\ngot error %v when getting logs for query: %s\n", qErr, lokiQuery)
return false, qErr
}
// return results if no error and result is empty
// caller should add assertions to ensure len([]FlowRecord) is as they expected for given loki query
return len(res.Data.Result) >= 0, nil
})
if err != nil {
return flowRecords, err
}
for _, result := range res.Data.Result {
flowRecords, err = getFlowRecords(result.Values)
if err != nil {
return []FlowRecord{}, err
}
}
return flowRecords, err
}
// TODO: add argument for condition to be matched.
// Get flows from Loki logs
func (lokilabels Lokilabels) getLokiFlowLogs(token, lokiRoute string, startTime time.Time, parameters ...string) ([]FlowRecord, error) {
lc := newLokiClient(lokiRoute, startTime).withToken(token).retry(5)
tenantID := "network"
lokiQuery := lokilabels.getLokiQuery("JSON", parameters...)
flowRecords := []FlowRecord{}
var res *lokiQueryResponse
err := wait.PollUntilContextTimeout(context.Background(), 30*time.Second, 300*time.Second, false, func(context.Context) (done bool, err error) {
var qErr error
res, qErr = lc.searchLogsInLoki(tenantID, lokiQuery)
if qErr != nil {
e2e.Logf("\ngot error %v when getting %s logs for query: %s\n", qErr, tenantID, lokiQuery)
return false, qErr
}
// return results if no error and result is empty
// caller should add assertions to ensure len([]FlowRecord) is as they expected for given loki query
return len(res.Data.Result) >= 0, nil
})
if err != nil {
return flowRecords, err
}
for _, result := range res.Data.Result {
flowRecords, err = getFlowRecords(result.Values)
if err != nil {
return []FlowRecord{}, err
}
}
return flowRecords, err
}
// Verify loki flow records and if it was written in the last 5 minutes
func verifyLokilogsTime(token, lokiRoute string, startTime time.Time) error {
lc := newLokiClient(lokiRoute, startTime).withToken(token).retry(5)
res, err := lc.searchLogsInLoki("network", "{app=\"netobserv-flowcollector\", FlowDirection=\"0\"}")
if err != nil {
return err
}
o.Expect(err).NotTo(o.HaveOccurred())
if len(res.Data.Result) == 0 {
exutil.AssertWaitPollNoErr(err, "network logs are not found")
}
flowRecords := []FlowRecord{}
for _, result := range res.Data.Result {
flowRecords, err = getFlowRecords(result.Values)
if err != nil {
return err
}
}
for _, r := range flowRecords {
r.Flowlog.verifyFlowRecord()
}
return nil
}
// Verify some key and deterministic conversation record fields and their values
func (flowlog *Flowlog) verifyConversationRecord() {
conversationRecord := fmt.Sprintf("Conversation record in error: %+v\n", flowlog)
o.Expect(flowlog.Bytes).Should(o.BeNumerically(">", 0), conversationRecord)
now := time.Now()
compareTime := now.Add(time.Duration(-2) * time.Hour)
compareTimeMs := compareTime.UnixMilli()
o.Expect(flowlog.TimeFlowEndMs).Should(o.BeNumerically(">", compareTimeMs), conversationRecord)
o.Expect(flowlog.TimeFlowStartMs).Should(o.BeNumerically(">", compareTimeMs), conversationRecord)
o.Expect(flowlog.HashId).NotTo(o.BeEmpty(), conversationRecord)
o.Expect(flowlog.NumFlowLogs).Should(o.BeNumerically(">", 0), conversationRecord)
}
// Verify loki conversation records and if it was written in the last 5 minutes
func verifyConversationRecordTime(record []FlowRecord) {
for _, r := range record {
r.Flowlog.verifyConversationRecord()
}
}
// Verify flow correctness based on number of bytes
func verifyFlowCorrectness(objectSize string, flowRecords []FlowRecord) {
var multiplier int = 0
switch unit := objectSize[len(objectSize)-1:]; unit {
case "K":
multiplier = 1024
case "M":
multiplier = 1024 * 1024
case "G":
multiplier = 1024 * 1024 * 1024
default:
panic("invalid object size unit")
}
nObject, _ := strconv.Atoi(objectSize[0 : len(objectSize)-1])
// minBytes is the size of the object fetched
minBytes := nObject * multiplier
// maxBytes is the minBytes +2% tolerance
maxBytes := int(float64(minBytes) + (float64(minBytes) * 0.02))
var errFlows float64 = 0
nflows := float64(len(flowRecords))
for _, r := range flowRecords {
// occurs very rarely but sometimes >= comparison can be flaky
// when eBPF-agent evicts packets sooner,
// currently it configured to be 15seconds.
if r.Flowlog.Bytes <= minBytes {
errFlows += 1
}
if r.Flowlog.Bytes >= maxBytes {
errFlows += 1
}
r.Flowlog.verifyFlowRecord()
}
// allow only 10% of flows to have Bytes violating minBytes and maxBytes.
tolerance := math.Ceil(nflows * 0.10)
o.Expect(errFlows).Should(o.BeNumerically("<=", tolerance))
}
// Verify Packet Translation feature flows
func verifyPacketTranslationFlows(oc *exutil.CLI, serverNS, clientNS string, flowRecords []FlowRecord) {
var nginxPodName []string
nginxPodName, err := exutil.GetAllPods(oc, serverNS)
o.Expect(err).NotTo(o.HaveOccurred())
nginxPodIP := getPodIPv4(oc, serverNS, nginxPodName[0])
clientPodIP := getPodIPv4(oc, clientNS, "client")
for _, r := range flowRecords {
o.Expect(r.Flowlog.XlatDstAddr).To(o.Equal(nginxPodIP))
o.Expect(r.Flowlog.XlatDstK8S_Name).To(o.Equal(nginxPodName[0]))
o.Expect(r.Flowlog.XlatDstK8S_Type).To(o.Equal("Pod"))
o.Expect(r.Flowlog.DstPort).Should(o.BeNumerically("==", 80))
o.Expect(r.Flowlog.XlatDstPort).Should(o.BeNumerically("==", 8080))
o.Expect(r.Flowlog.XlatSrcAddr).To(o.Equal(clientPodIP))
o.Expect(r.Flowlog.XlatSrcK8S_Name).To(o.Equal("client"))
o.Expect(r.Flowlog.ZoneId).Should(o.BeNumerically(">=", 0))
}
}
// Verify Network Events feature flows
func verifyNetworkEvents(flowRecords []FlowRecord, action, policytype, direction string) {
nNWEventsLogs := 0
for _, flow := range flowRecords {
nwevent := flow.Flowlog.NetworkEvents
if len(nwevent) >= 1 {
e2e.Logf("found nwevent %v", nwevent)
// usually for our scenario we expect only one nw event
// but there could be more than 1.
o.Expect(nwevent[0].Action).Should(o.Equal(action))
o.Expect(nwevent[0].Type).Should(o.Equal(policytype))
o.Expect(nwevent[0].Direction).Should(o.Equal(direction))
nNWEventsLogs += 1
} else {
e2e.Logf("nwevent missing %v", flow.Flowlog)
}
}
o.Expect(nNWEventsLogs).Should(o.BeNumerically(">=", 1), "Found no logs with Network Events")
}
func removeSAFromAdmin(oc *exutil.CLI, saName, namespace string) error {
return oc.WithoutNamespace().AsAdmin().Run("adm").Args("policy", "remove-cluster-role-from-user", "cluster-admin", "-z", saName, "-n", namespace).Execute()
}
func addSAToAdmin(oc *exutil.CLI, saName, namespace string) error {
return oc.WithoutNamespace().AsAdmin().Run("adm").Args("policy", "add-cluster-role-to-user", "cluster-admin", "-z", saName, "-n", namespace).Execute()
}
|
package netobserv
| ||||
function
|
openshift/openshift-tests-private
|
17dcccbd-bb93-495b-8a31-0664235c1601
|
isFlowCollectorAPIExists
|
['"strings"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/flowcollector_utils.go
|
func isFlowCollectorAPIExists(oc *exutil.CLI) (bool, error) {
stdout, err := oc.AsAdmin().WithoutNamespace().Run("get").Args("crd", "-o", "jsonpath='{.items[*].spec.names.kind}'").Output()
if err != nil {
return false, err
}
return strings.Contains(stdout, "FlowCollector"), nil
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
e32d9271-174c-4425-8a7e-b0c8bf6cc4d3
|
verifyFlowRecordFromLogs
|
['"regexp"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/flowcollector_utils.go
|
func verifyFlowRecordFromLogs(podLog string) {
re := regexp.MustCompile("{\"AgentIP\":.*")
flowRecords := re.FindAllString(podLog, -3)
partialFlowRegex, err := regexp.Compile("DstMac\":\"00:00:00:00:00:00")
for _, flow := range flowRecords {
// skip assertions and log Partial flows
o.Expect(err).NotTo(o.HaveOccurred())
if partialFlowRegex.Match([]byte(flow)) {
e2e.Logf("Found partial flows %s", flow)
} else {
o.Expect(flow).Should(o.And(
o.MatchRegexp("Bytes.:[0-9]+"),
o.MatchRegexp("TimeFlowEndMs.:[1-9][0-9]+"),
o.MatchRegexp("TimeFlowStartMs.:[1-9][0-9]+"),
o.MatchRegexp("TimeReceived.:[1-9][0-9]+")), flow)
}
}
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
c12e9e88-273e-476f-99aa-39db2241646a
|
getFlowRecords
|
['"encoding/json"', '"strconv"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/flowcollector_utils.go
|
func getFlowRecords(lokiValues [][]string) ([]FlowRecord, error) {
flowRecords := []FlowRecord{}
for _, values := range lokiValues {
timestamp, _ := strconv.ParseInt(values[0], 10, 64)
var flowlog Flowlog
err := json.Unmarshal([]byte(values[1]), &flowlog)
if err != nil {
return []FlowRecord{}, err
}
flowRecord := FlowRecord{
Timestamp: timestamp,
Flowlog: flowlog,
}
flowRecords = append(flowRecords, flowRecord)
}
return flowRecords, nil
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
2af70191-149d-4a57-8ac0-08d8ddac416d
|
verifyFlowRecord
|
['"fmt"', '"time"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/flowcollector_utils.go
|
func (flowlog *Flowlog) verifyFlowRecord() {
flow := fmt.Sprintf("Flow log is: %+v\n", flowlog)
o.Expect(flowlog.AgentIP).To(o.Equal(flowlog.DstK8S_HostIP), flow)
o.Expect(flowlog.Bytes).Should(o.BeNumerically(">", 0), flow)
now := time.Now()
compareTime := now.Add(time.Duration(-2) * time.Hour)
compareTimeMs := compareTime.UnixMilli()
o.Expect(flowlog.TimeFlowEndMs).Should(o.BeNumerically(">", compareTimeMs), flow)
o.Expect(flowlog.TimeFlowStartMs).Should(o.BeNumerically(">", compareTimeMs), flow)
o.Expect(flowlog.TimeReceived).Should(o.BeNumerically(">", compareTime.Unix()), flow)
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
fa8c88fa-5198-4f95-89ab-0eafa4646694
|
getLokiQueryLabels
|
['"fmt"', '"reflect"', '"strings"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/flowcollector_utils.go
|
func (lokilabels Lokilabels) getLokiQueryLabels() string {
label := reflect.ValueOf(&lokilabels).Elem()
var lokiQuery = "{"
for i := 0; i < label.NumField(); i++ {
if label.Field(i).Interface() != "" {
switch labelName := label.Type().Field(i).Name; labelName {
case "App":
lokiQuery += fmt.Sprintf("%s=\"%s\", ", strings.ToLower(label.Type().Field(i).Name), label.Field(i).Interface())
case "RecordType":
lokiQuery += fmt.Sprintf("_%s=\"%s\", ", label.Type().Field(i).Name, label.Field(i).Interface())
case "FlowDirection":
if label.Field(i).Interface() == "0" || label.Field(i).Interface() == "1" || label.Field(i).Interface() == "2" {
lokiQuery += fmt.Sprintf("%s=\"%s\", ", label.Type().Field(i).Name, label.Field(i).Interface())
}
default:
lokiQuery += fmt.Sprintf("%s=\"%s\", ", label.Type().Field(i).Name, label.Field(i).Interface())
}
}
}
lokiQuery = strings.TrimSuffix(lokiQuery, ", ")
lokiQuery += "}"
return lokiQuery
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
a9cd6398-3f6e-4d25-9d4a-55e3aba49d9c
|
getLokiJSONfilterQuery
|
['"encoding/json"', '"fmt"', '"strings"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/flowcollector_utils.go
|
func (lokilabels Lokilabels) getLokiJSONfilterQuery(parameters ...string) string {
lokiQuery := lokilabels.getLokiQueryLabels()
if len(parameters) != 0 {
lokiQuery += " | json"
for _, p := range parameters {
if strings.Contains(p, "Flags") {
lokiQuery += fmt.Sprintf(" %s | json", p)
} else {
lokiQuery += fmt.Sprintf(" | %s", p)
}
}
}
e2e.Logf("Loki query is %s", lokiQuery)
return lokiQuery
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
cc43641e-0962-4f68-afd2-814298fb5d07
|
getLokiRegexFilterQuery
|
['"fmt"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/flowcollector_utils.go
|
func (lokilabels Lokilabels) getLokiRegexFilterQuery(parameters ...string) string {
lokiQuery := lokilabels.getLokiQueryLabels()
if len(parameters) != 0 {
for _, p := range parameters {
lokiQuery += fmt.Sprintf(" |~ %s", p)
}
}
e2e.Logf("Loki query is %s", lokiQuery)
return lokiQuery
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
1a3d760b-3149-42c3-88f8-ae51e0dbf94b
|
getLokiQuery
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/flowcollector_utils.go
|
func (lokilabels Lokilabels) getLokiQuery(filterType string, parameters ...string) string {
var lokiQuery string
switch filterType {
case "JSON":
lokiQuery = lokilabels.getLokiJSONfilterQuery(parameters...)
case "REGEX":
lokiQuery = lokilabels.getLokiRegexFilterQuery(parameters...)
default:
panic("loki filter is not supported yet")
}
return lokiQuery
}
|
netobserv
| |||||
function
|
openshift/openshift-tests-private
|
4f7b439d-c6ba-4cd3-a830-16287598d249
|
GetMonolithicLokiFlowLogs
|
['"context"', '"time"', '"k8s.io/apimachinery/pkg/util/wait"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/flowcollector_utils.go
|
func (lokilabels Lokilabels) GetMonolithicLokiFlowLogs(lokiRoute string, startTime time.Time, parameters ...string) ([]FlowRecord, error) {
lc := newLokiClient(lokiRoute, startTime).retry(5)
lc.quiet = false
lc.localhost = true
lokiQuery := lokilabels.getLokiQuery("REGEX", parameters...)
flowRecords := []FlowRecord{}
var res *lokiQueryResponse
err := wait.PollUntilContextTimeout(context.Background(), 30*time.Second, 300*time.Second, false, func(context.Context) (done bool, err error) {
var qErr error
res, qErr = lc.searchLogsInLoki("", lokiQuery)
if qErr != nil {
e2e.Logf("\ngot error %v when getting logs for query: %s\n", qErr, lokiQuery)
return false, qErr
}
// return results if no error and result is empty
// caller should add assertions to ensure len([]FlowRecord) is as they expected for given loki query
return len(res.Data.Result) >= 0, nil
})
if err != nil {
return flowRecords, err
}
for _, result := range res.Data.Result {
flowRecords, err = getFlowRecords(result.Values)
if err != nil {
return []FlowRecord{}, err
}
}
return flowRecords, err
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
d93300d3-6713-44e4-8221-bb00264f004d
|
getLokiFlowLogs
|
['"context"', '"time"', '"k8s.io/apimachinery/pkg/util/wait"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/flowcollector_utils.go
|
func (lokilabels Lokilabels) getLokiFlowLogs(token, lokiRoute string, startTime time.Time, parameters ...string) ([]FlowRecord, error) {
lc := newLokiClient(lokiRoute, startTime).withToken(token).retry(5)
tenantID := "network"
lokiQuery := lokilabels.getLokiQuery("JSON", parameters...)
flowRecords := []FlowRecord{}
var res *lokiQueryResponse
err := wait.PollUntilContextTimeout(context.Background(), 30*time.Second, 300*time.Second, false, func(context.Context) (done bool, err error) {
var qErr error
res, qErr = lc.searchLogsInLoki(tenantID, lokiQuery)
if qErr != nil {
e2e.Logf("\ngot error %v when getting %s logs for query: %s\n", qErr, tenantID, lokiQuery)
return false, qErr
}
// return results if no error and result is empty
// caller should add assertions to ensure len([]FlowRecord) is as they expected for given loki query
return len(res.Data.Result) >= 0, nil
})
if err != nil {
return flowRecords, err
}
for _, result := range res.Data.Result {
flowRecords, err = getFlowRecords(result.Values)
if err != nil {
return []FlowRecord{}, err
}
}
return flowRecords, err
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
edfdd362-9a1e-4455-96cc-35180e146050
|
verifyLokilogsTime
|
['"time"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/flowcollector_utils.go
|
func verifyLokilogsTime(token, lokiRoute string, startTime time.Time) error {
lc := newLokiClient(lokiRoute, startTime).withToken(token).retry(5)
res, err := lc.searchLogsInLoki("network", "{app=\"netobserv-flowcollector\", FlowDirection=\"0\"}")
if err != nil {
return err
}
o.Expect(err).NotTo(o.HaveOccurred())
if len(res.Data.Result) == 0 {
exutil.AssertWaitPollNoErr(err, "network logs are not found")
}
flowRecords := []FlowRecord{}
for _, result := range res.Data.Result {
flowRecords, err = getFlowRecords(result.Values)
if err != nil {
return err
}
}
for _, r := range flowRecords {
r.Flowlog.verifyFlowRecord()
}
return nil
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
ed9c817d-0238-491e-9c8d-139ea2ea566d
|
verifyConversationRecord
|
['"fmt"', '"time"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/flowcollector_utils.go
|
func (flowlog *Flowlog) verifyConversationRecord() {
conversationRecord := fmt.Sprintf("Conversation record in error: %+v\n", flowlog)
o.Expect(flowlog.Bytes).Should(o.BeNumerically(">", 0), conversationRecord)
now := time.Now()
compareTime := now.Add(time.Duration(-2) * time.Hour)
compareTimeMs := compareTime.UnixMilli()
o.Expect(flowlog.TimeFlowEndMs).Should(o.BeNumerically(">", compareTimeMs), conversationRecord)
o.Expect(flowlog.TimeFlowStartMs).Should(o.BeNumerically(">", compareTimeMs), conversationRecord)
o.Expect(flowlog.HashId).NotTo(o.BeEmpty(), conversationRecord)
o.Expect(flowlog.NumFlowLogs).Should(o.BeNumerically(">", 0), conversationRecord)
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
2b93a586-1d19-490d-8c71-99c0a4361dae
|
verifyConversationRecordTime
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/flowcollector_utils.go
|
func verifyConversationRecordTime(record []FlowRecord) {
for _, r := range record {
r.Flowlog.verifyConversationRecord()
}
}
|
netobserv
| |||||
function
|
openshift/openshift-tests-private
|
10cef7d6-7370-4faa-b712-ecae46de925b
|
verifyFlowCorrectness
|
['"math"', '"strconv"']
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/flowcollector_utils.go
|
func verifyFlowCorrectness(objectSize string, flowRecords []FlowRecord) {
var multiplier int = 0
switch unit := objectSize[len(objectSize)-1:]; unit {
case "K":
multiplier = 1024
case "M":
multiplier = 1024 * 1024
case "G":
multiplier = 1024 * 1024 * 1024
default:
panic("invalid object size unit")
}
nObject, _ := strconv.Atoi(objectSize[0 : len(objectSize)-1])
// minBytes is the size of the object fetched
minBytes := nObject * multiplier
// maxBytes is the minBytes +2% tolerance
maxBytes := int(float64(minBytes) + (float64(minBytes) * 0.02))
var errFlows float64 = 0
nflows := float64(len(flowRecords))
for _, r := range flowRecords {
// occurs very rarely but sometimes >= comparison can be flaky
// when eBPF-agent evicts packets sooner,
// currently it configured to be 15seconds.
if r.Flowlog.Bytes <= minBytes {
errFlows += 1
}
if r.Flowlog.Bytes >= maxBytes {
errFlows += 1
}
r.Flowlog.verifyFlowRecord()
}
// allow only 10% of flows to have Bytes violating minBytes and maxBytes.
tolerance := math.Ceil(nflows * 0.10)
o.Expect(errFlows).Should(o.BeNumerically("<=", tolerance))
}
|
netobserv
| ||||
function
|
openshift/openshift-tests-private
|
d0afa711-dabe-48ea-89c1-1a6b768efb21
|
verifyPacketTranslationFlows
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/flowcollector_utils.go
|
func verifyPacketTranslationFlows(oc *exutil.CLI, serverNS, clientNS string, flowRecords []FlowRecord) {
var nginxPodName []string
nginxPodName, err := exutil.GetAllPods(oc, serverNS)
o.Expect(err).NotTo(o.HaveOccurred())
nginxPodIP := getPodIPv4(oc, serverNS, nginxPodName[0])
clientPodIP := getPodIPv4(oc, clientNS, "client")
for _, r := range flowRecords {
o.Expect(r.Flowlog.XlatDstAddr).To(o.Equal(nginxPodIP))
o.Expect(r.Flowlog.XlatDstK8S_Name).To(o.Equal(nginxPodName[0]))
o.Expect(r.Flowlog.XlatDstK8S_Type).To(o.Equal("Pod"))
o.Expect(r.Flowlog.DstPort).Should(o.BeNumerically("==", 80))
o.Expect(r.Flowlog.XlatDstPort).Should(o.BeNumerically("==", 8080))
o.Expect(r.Flowlog.XlatSrcAddr).To(o.Equal(clientPodIP))
o.Expect(r.Flowlog.XlatSrcK8S_Name).To(o.Equal("client"))
o.Expect(r.Flowlog.ZoneId).Should(o.BeNumerically(">=", 0))
}
}
|
netobserv
| |||||
function
|
openshift/openshift-tests-private
|
3244ab19-d441-447b-a953-2df8a07487db
|
verifyNetworkEvents
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/flowcollector_utils.go
|
func verifyNetworkEvents(flowRecords []FlowRecord, action, policytype, direction string) {
nNWEventsLogs := 0
for _, flow := range flowRecords {
nwevent := flow.Flowlog.NetworkEvents
if len(nwevent) >= 1 {
e2e.Logf("found nwevent %v", nwevent)
// usually for our scenario we expect only one nw event
// but there could be more than 1.
o.Expect(nwevent[0].Action).Should(o.Equal(action))
o.Expect(nwevent[0].Type).Should(o.Equal(policytype))
o.Expect(nwevent[0].Direction).Should(o.Equal(direction))
nNWEventsLogs += 1
} else {
e2e.Logf("nwevent missing %v", flow.Flowlog)
}
}
o.Expect(nNWEventsLogs).Should(o.BeNumerically(">=", 1), "Found no logs with Network Events")
}
|
netobserv
| |||||
function
|
openshift/openshift-tests-private
|
64e06092-7f70-46d0-a1e7-b92fe70467e2
|
removeSAFromAdmin
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/flowcollector_utils.go
|
func removeSAFromAdmin(oc *exutil.CLI, saName, namespace string) error {
return oc.WithoutNamespace().AsAdmin().Run("adm").Args("policy", "remove-cluster-role-from-user", "cluster-admin", "-z", saName, "-n", namespace).Execute()
}
|
netobserv
| |||||
function
|
openshift/openshift-tests-private
|
750df68f-6542-4abe-ab27-f9a592dd6f0f
|
addSAToAdmin
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/flowcollector_utils.go
|
func addSAToAdmin(oc *exutil.CLI, saName, namespace string) error {
return oc.WithoutNamespace().AsAdmin().Run("adm").Args("policy", "add-cluster-role-to-user", "cluster-admin", "-z", saName, "-n", namespace).Execute()
}
|
netobserv
| |||||
file
|
openshift/openshift-tests-private
|
a41d54ae-89b8-4b2c-af9b-a2ee0a488e87
|
loki
|
import (
"fmt"
"reflect"
"strings"
o "github.com/onsi/gomega"
exutil "github.com/openshift/openshift-tests-private/test/extended/util"
e2e "k8s.io/kubernetes/test/e2e/framework"
)
|
github.com/openshift/openshift-tests-private/test/extended/netobserv/loki.go
|
package netobserv
import (
"fmt"
"reflect"
"strings"
o "github.com/onsi/gomega"
exutil "github.com/openshift/openshift-tests-private/test/extended/util"
e2e "k8s.io/kubernetes/test/e2e/framework"
)
// lokiStack contains the configurations of loki stack
type lokiStack struct {
Name string // lokiStack name
Namespace string // lokiStack namespace
TSize string // size
StorageType string // the backend storage type, currently support s3, gcs, azure, swift, ODF and minIO
StorageSecret string // the secret name for loki to use to connect to backend storage
StorageClass string // storage class name
BucketName string // the butcket or the container name where loki stores it's data in
Tenant string // Loki tenant name
Template string // the file used to create the loki stack
Route string // lokistack-gateway-http route to be initialized after lokistack is up.
EnableIPV6 string // enable IPV6
}
// LokiPersistentVolumeClaim struct to handle Loki PVC resources
type LokiPersistentVolumeClaim struct {
Namespace string
Template string
}
// LokiStorage struct to handle LokiStorage resources
type LokiStorage struct {
Namespace string
Template string
}
// deploy LokiPVC
func (loki *LokiPersistentVolumeClaim) deployLokiPVC(oc *exutil.CLI) {
e2e.Logf("Deploy Loki PVC")
parameters := []string{"--ignore-unknown-parameters=true", "-f", loki.Template, "-p", "NAMESPACE=" + loki.Namespace}
exutil.ApplyNsResourceFromTemplate(oc, loki.Namespace, parameters...)
}
// deploy LokiStorage
func (loki *LokiStorage) deployLokiStorage(oc *exutil.CLI) {
e2e.Logf("Deploy Loki storage")
parameters := []string{"--ignore-unknown-parameters=true", "-f", loki.Template, "-p", "NAMESPACE=" + loki.Namespace}
exutil.ApplyNsResourceFromTemplate(oc, loki.Namespace, parameters...)
}
// delete LokiStorage
func (loki *LokiStorage) deleteLokiStorage(oc *exutil.CLI) {
e2e.Logf("Delete Loki PVC")
command1 := []string{"pod", "loki", "-n", loki.Namespace}
_, err1 := oc.AsAdmin().WithoutNamespace().Run("delete").Args(command1...).Output()
command2 := []string{"configmap", "loki-config", "-n", loki.Namespace}
_, err2 := oc.AsAdmin().WithoutNamespace().Run("delete").Args(command2...).Output()
command3 := []string{"service", "loki", "-n", loki.Namespace}
_, err3 := oc.AsAdmin().WithoutNamespace().Run("delete").Args(command3...).Output()
o.Expect(err1).NotTo(o.HaveOccurred())
o.Expect(err2).NotTo(o.HaveOccurred())
o.Expect(err3).NotTo(o.HaveOccurred())
}
// DeployLokiStack creates the lokiStack CR with basic settings: name, namespace, size, storage.secret.name, storage.secret.type, storageClassName
// optionalParameters is designed for adding parameters to deploy lokiStack with different tenants or some other settings
func (l lokiStack) deployLokiStack(oc *exutil.CLI) error {
parameters := []string{"--ignore-unknown-parameters=true", "-f", l.Template, "-p"}
lokistack := reflect.ValueOf(&l).Elem()
for i := 0; i < lokistack.NumField(); i++ {
if lokistack.Field(i).Interface() != "" {
if lokistack.Type().Field(i).Name == "StorageType" {
if lokistack.Field(i).Interface() == "odf" || lokistack.Field(i).Interface() == "minio" {
parameters = append(parameters, fmt.Sprintf("%s=%s", lokistack.Type().Field(i).Name, "s3"))
} else {
parameters = append(parameters, fmt.Sprintf("%s=%s", lokistack.Type().Field(i).Name, lokistack.Field(i).Interface()))
}
} else {
if lokistack.Type().Field(i).Name == "Template" {
continue
} else {
parameters = append(parameters, fmt.Sprintf("%s=%s", lokistack.Type().Field(i).Name, lokistack.Field(i).Interface()))
}
}
}
}
file, err := processTemplate(oc, parameters...)
exutil.AssertWaitPollNoErr(err, fmt.Sprintf("Can not process %v", parameters))
err = oc.AsAdmin().WithoutNamespace().Run("apply").Args("-f", file, "-n", l.Namespace).Execute()
return err
}
func (l lokiStack) waitForLokiStackToBeReady(oc *exutil.CLI) error {
var err error
for _, deploy := range []string{l.Name + "-distributor", l.Name + "-gateway", l.Name + "-querier", l.Name + "-query-frontend"} {
err = waitForDeploymentPodsToBeReady(oc, l.Namespace, deploy)
}
for _, ss := range []string{l.Name + "-compactor", l.Name + "-index-gateway", l.Name + "-ingester"} {
err = waitForStatefulsetReady(oc, l.Namespace, ss)
}
return err
}
func (l lokiStack) removeLokiStack(oc *exutil.CLI) {
Resource{"lokistack", l.Name, l.Namespace}.clear(oc)
_ = oc.AsAdmin().WithoutNamespace().Run("delete").Args("pvc", "-n", l.Namespace, "-l", "app.kubernetes.io/instance="+l.Name).Execute()
}
// Get OIDC provider for the cluster
func getOIDC(oc *exutil.CLI) (string, error) {
oidc, err := oc.AsAdmin().WithoutNamespace().Run("get").Args("authentication.config", "cluster", "-o=jsonpath={.spec.serviceAccountIssuer}").Output()
if err != nil {
return "", err
}
return strings.TrimPrefix(oidc, "https://"), nil
}
func getLokiChannel(oc *exutil.CLI, catalog string) (lokiChannel string, err error) {
channels, err := oc.AsAdmin().WithoutNamespace().Run("get").Args("packagemanifests", "-l", "catalog="+catalog, "-n", "openshift-marketplace", "-o=jsonpath={.items[?(@.metadata.name==\"loki-operator\")].status.channels[*].name}").Output()
channelArr := strings.Split(channels, " ")
return channelArr[len(channelArr)-1], err
}
|
package netobserv
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.