de-linting (#3)

controller/tunnel.go

@@ -6,6 +6,7 @@ import (
 	"github.com/go-openapi/runtime/middleware"
 	"github.com/openziti-test-kitchen/zrok/rest_model_zrok"
 	"github.com/openziti-test-kitchen/zrok/rest_server_zrok/operations/tunnel"
+	"github.com/openziti/edge/rest_management_api_client"
 	"github.com/openziti/edge/rest_management_api_client/edge_router_policy"
 	"github.com/openziti/edge/rest_management_api_client/service"
 	"github.com/openziti/edge/rest_management_api_client/service_edge_router_policy"
@@ -22,113 +23,154 @@ func tunnelHandler(params tunnel.TunnelParams) middleware.Responder {
 		return middleware.Error(500, err.Error())
 	}
 
-	serviceId, err := randomId()
+	svcName, err := randomId()
 	if err != nil {
 		logrus.Error(err)
 		return middleware.Error(500, err.Error())
 	}
-	logrus.Infof("using service '%v'", serviceId)
+	logrus.Infof("allocated service '%v'", svcName)
 
-	semantic := rest_model.SemanticAllOf
+	svcId, err := createService(svcName, edge)
-
+	if err != nil {
-	// Service
+		logrus.Error(err)
-	svcConfigs := make([]string, 0)
+		return middleware.Error(500, err.Error())
-	svcEnc := true
-	svc := &rest_model.ServiceCreate{
-		Configs:            svcConfigs,
-		EncryptionRequired: &svcEnc,
-		Name:               &serviceId,
 	}
-	svcParams := &service.CreateServiceParams{
+	envId := params.Body.Identity
+
+	if err := createServicePolicyBind(svcName, svcId, envId, edge); err != nil {
+		logrus.Error(err)
+		return middleware.Error(500, err.Error())
+	}
+
+	if err := createServicePolicyDial(svcName, svcId, edge); err != nil {
+		logrus.Error(err)
+		return middleware.Error(500, err.Error())
+	}
+
+	if err := createServiceEdgeRouterPolicy(svcName, svcId, edge); err != nil {
+		logrus.Error(err)
+		return middleware.Error(500, err.Error())
+	}
+
+	if err := createEdgeRouterPolicy(svcName, envId, edge); err != nil {
+		logrus.Error(err)
+		return middleware.Error(500, err.Error())
+	}
+
+	resp := tunnel.NewTunnelCreated().WithPayload(&rest_model_zrok.TunnelResponse{
+		Service: svcName,
+	})
+	return resp
+}
+
+func createService(name string, edge *rest_management_api_client.ZitiEdgeManagement) (serviceId string, err error) {
+	configs := make([]string, 0)
+	encryptionRequired := true
+	svc := &rest_model.ServiceCreate{
+		Configs:            configs,
+		EncryptionRequired: &encryptionRequired,
+		Name:               &name,
+	}
+	req := &service.CreateServiceParams{
 		Service: svc,
 		Context: context.Background(),
 	}
-	svcParams.SetTimeout(30 * time.Second)
+	req.SetTimeout(30 * time.Second)
-	svcResp, err := edge.Service.CreateService(svcParams, nil)
+	resp, err := edge.Service.CreateService(req, nil)
 	if err != nil {
-		logrus.Error(err)
+		return "", err
-		return middleware.Error(500, err.Error())
 	}
-	logrus.Infof("created service '%v'", serviceId)
+	logrus.Infof("created service '%v'", resp.Payload.Data.ID)
+	return resp.Payload.Data.ID, nil
+}
 
-	// Service Policy (Bind)
+func createServicePolicyBind(svcName, svcId, envId string, edge *rest_management_api_client.ZitiEdgeManagement) error {
-	svcpIdRoles := []string{fmt.Sprintf("@%v", params.Body.Identity)}
+	semantic := rest_model.SemanticAllOf
-	svcpName := fmt.Sprintf("%v-bind", serviceId)
+	identityRoles := []string{fmt.Sprintf("@%v", envId)}
-	svcpPcRoles := []string{}
+	name := fmt.Sprintf("%v-bind", svcName)
-	svcpSvcRoles := []string{fmt.Sprintf("@%v", svcResp.Payload.Data.ID)}
+	postureCheckRoles := []string{}
-	svcpDialBind := rest_model.DialBindBind
+	serviceRoles := []string{fmt.Sprintf("@%v", svcId)}
+	dialBind := rest_model.DialBindBind
 	svcp := &rest_model.ServicePolicyCreate{
-		IdentityRoles:     svcpIdRoles,
+		IdentityRoles:     identityRoles,
-		Name:              &svcpName,
+		Name:              &name,
-		PostureCheckRoles: svcpPcRoles,
+		PostureCheckRoles: postureCheckRoles,
 		Semantic:          &semantic,
-		ServiceRoles:      svcpSvcRoles,
+		ServiceRoles:      serviceRoles,
-		Type:              &svcpDialBind,
+		Type:              &dialBind,
 	}
-	svcpParams := &service_policy.CreateServicePolicyParams{
+	req := &service_policy.CreateServicePolicyParams{
 		Policy:  svcp,
 		Context: context.Background(),
 	}
-	svcpParams.SetTimeout(30 * time.Second)
+	req.SetTimeout(30 * time.Second)
-	_, err = edge.ServicePolicy.CreateServicePolicy(svcpParams, nil)
+	_, err := edge.ServicePolicy.CreateServicePolicy(req, nil)
 	if err != nil {
-		logrus.Error(err)
+		return err
-		return middleware.Error(500, err.Error())
 	}
-	logrus.Infof("created service policy '%v' (bind)", serviceId)
+	logrus.Infof("created service policy '%v'", name)
+	return nil
+}
 
-	// Service Policy (Dial)
+func createServicePolicyDial(svcName, svcId string, edge *rest_management_api_client.ZitiEdgeManagement) error {
-	svcpIdRoles = []string{"@PyB606.S."} // @proxy
+	identityRoles := []string{"@PyB606.S."} // @proxy
-	svcpName = fmt.Sprintf("%v-dial", serviceId)
+	name := fmt.Sprintf("%v-dial", svcName)
-	svcpDialBind = rest_model.DialBindDial
+	postureCheckRoles := []string{}
-	svcp = &rest_model.ServicePolicyCreate{
+	semantic := rest_model.SemanticAllOf
-		IdentityRoles:     svcpIdRoles,
+	serviceRoles := []string{fmt.Sprintf("@%v", svcId)}
-		Name:              &svcpName,
+	dialBind := rest_model.DialBindDial
-		PostureCheckRoles: svcpPcRoles,
+	svcp := &rest_model.ServicePolicyCreate{
+		IdentityRoles:     identityRoles,
+		Name:              &name,
+		PostureCheckRoles: postureCheckRoles,
 		Semantic:          &semantic,
-		ServiceRoles:      svcpSvcRoles,
+		ServiceRoles:      serviceRoles,
-		Type:              &svcpDialBind,
+		Type:              &dialBind,
 	}
-	svcpParams = &service_policy.CreateServicePolicyParams{
+	req := &service_policy.CreateServicePolicyParams{
 		Policy:  svcp,
 		Context: context.Background(),
 	}
-	svcpParams.SetTimeout(30 * time.Second)
+	req.SetTimeout(30 * time.Second)
-	_, err = edge.ServicePolicy.CreateServicePolicy(svcpParams, nil)
+	_, err := edge.ServicePolicy.CreateServicePolicy(req, nil)
 	if err != nil {
-		logrus.Error(err)
+		return err
-		return middleware.Error(500, err.Error())
 	}
-	logrus.Infof("created service policy '%v' (dial)", serviceId)
+	logrus.Infof("created service policy '%v'", name)
+	return nil
+}
 
-	// Service Edge Router Policy
+func createServiceEdgeRouterPolicy(svcName, svcId string, edge *rest_management_api_client.ZitiEdgeManagement) error {
-	serpErRoles := []string{"@tDnhG8jkG9"} // @linux-edge-router
+	edgeRouterRoles := []string{"@tDnhG8jkG9"} // @linux-edge-router
-	serpSvcRoles := []string{fmt.Sprintf("@%v", svcResp.Payload.Data.ID)}
+	semantic := rest_model.SemanticAllOf
+	serviceRoles := []string{fmt.Sprintf("@%v", svcId)}
 	serp := &rest_model.ServiceEdgeRouterPolicyCreate{
-		EdgeRouterRoles: serpErRoles,
+		EdgeRouterRoles: edgeRouterRoles,
-		Name:            &serviceId,
+		Name:            &svcName,
 		Semantic:        &semantic,
-		ServiceRoles:    serpSvcRoles,
+		ServiceRoles:    serviceRoles,
 	}
 	serpParams := &service_edge_router_policy.CreateServiceEdgeRouterPolicyParams{
 		Policy:  serp,
 		Context: context.Background(),
 	}
 	serpParams.SetTimeout(30 * time.Second)
-	_, err = edge.ServiceEdgeRouterPolicy.CreateServiceEdgeRouterPolicy(serpParams, nil)
+	_, err := edge.ServiceEdgeRouterPolicy.CreateServiceEdgeRouterPolicy(serpParams, nil)
 	if err != nil {
-		logrus.Error(err)
+		return err
-		return middleware.Error(500, err.Error())
 	}
-	logrus.Infof("created service edge router policy '%v'", serviceId)
+	logrus.Infof("created service edge router policy '%v'", svcName)
+	return nil
+}
 
-	// Edge Router Policy
+func createEdgeRouterPolicy(svcName, envId string, edge *rest_management_api_client.ZitiEdgeManagement) error {
-	erpErRoles := []string{"@tDnhG8jkG9"} // @linux-edge-router
+	edgeRouterRoles := []string{"@tDnhG8jkG9"} // @linux-edge-router
-	erpIdRoles := []string{fmt.Sprintf("@%v", params.Body.Identity)}
+	identityRoles := []string{fmt.Sprintf("@%v", envId)}
+	semantic := rest_model.SemanticAllOf
 	erp := &rest_model.EdgeRouterPolicyCreate{
-		EdgeRouterRoles: erpErRoles,
+		EdgeRouterRoles: edgeRouterRoles,
-		IdentityRoles:   erpIdRoles,
+		IdentityRoles:   identityRoles,
-		Name:            &serviceId,
+		Name:            &svcName,
 		Semantic:        &semantic,
 	}
 	erpParams := &edge_router_policy.CreateEdgeRouterPolicyParams{
@@ -136,15 +178,10 @@ func tunnelHandler(params tunnel.TunnelParams) middleware.Responder {
 		Context: context.Background(),
 	}
 	erpParams.SetTimeout(30 * time.Second)
-	_, err = edge.EdgeRouterPolicy.CreateEdgeRouterPolicy(erpParams, nil)
+	_, err := edge.EdgeRouterPolicy.CreateEdgeRouterPolicy(erpParams, nil)
 	if err != nil {
-		logrus.Error(err)
+		return err
-		return middleware.Error(500, err.Error())
 	}
-	logrus.Infof("created edge router policy '%v'", serviceId)
+	logrus.Infof("created edge router policy '%v'", svcName)
-
+	return nil
-	resp := tunnel.NewTunnelCreated().WithPayload(&rest_model_zrok.TunnelResponse{
-		Service: serviceId,
-	})
-	return resp
 }