extern/zrok
1
1
Fork 0
mirror of https://github.com/openziti/zrok.git synced 2025-04-10 00:48:53 +02:00
Code Issues Packages Projects Releases Wiki Activity

naming clarification

Browse Source
This commit is contained in:
Michael Quigley 2022-10-19 12:10:22 -04:00
parent 4a69d9dd31
commit 2d75181483
No known key found for this signature in database
GPG Key ID: 9B60314A9DD20A62
7 changed files with 41 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
controller/disable.go
View File

@ -76,7 +76,7 @@ func (self *disableHandler) removeServicesForEnvironment(envId int, tx *sqlx.Tx,
return err return err
} }
for _, svc := range svcs { for _, svc := range svcs {
svcName := svc.ZrokServiceId svcName := svc.Name
logrus.Infof("garbage collecting service '%v'", svcName) logrus.Infof("garbage collecting service '%v'", svcName)
if err := deleteServiceEdgeRouterPolicy(svcName, edge); err != nil { if err := deleteServiceEdgeRouterPolicy(svcName, edge); err != nil {
logrus.Error(err) logrus.Error(err)
@ -90,10 +90,10 @@ func (self *disableHandler) removeServicesForEnvironment(envId int, tx *sqlx.Tx,
if err := deleteConfig(svcName, edge); err != nil { if err := deleteConfig(svcName, edge); err != nil {
logrus.Error(err) logrus.Error(err)
} }
if err := deleteService(svc.ZitiServiceId, edge); err != nil { if err := deleteService(svc.ZId, edge); err != nil {
logrus.Error(err) logrus.Error(err)
} }
logrus.Infof("removed service '%v'", svc.ZrokServiceId) logrus.Infof("removed service '%v'", svc.Name)
} }
return nil return nil
} }

2
controller/gc.go
View File

@ -41,7 +41,7 @@ func GC(cfg *Config) error {
} }
liveMap := make(map[string]struct{}) liveMap := make(map[string]struct{})
for _, dbSvc := range dbSvcs { for _, dbSvc := range dbSvcs {
liveMap[dbSvc.ZrokServiceId] = struct{}{} liveMap[dbSvc.Name] = struct{}{}
} }
if err := gcServices(edge, liveMap); err != nil { if err := gcServices(edge, liveMap); err != nil {
return errors.Wrap(err, "error garbage collecting services") return errors.Wrap(err, "error garbage collecting services")

4
controller/overview.go
View File

@ -44,8 +44,8 @@ func overviewHandler(_ metadata.OverviewParams, principal *rest_model_zrok.Princ
Frontend: svc.Frontend, Frontend: svc.Frontend,
Backend: svc.Backend, Backend: svc.Backend,
UpdatedAt: svc.UpdatedAt.String(), UpdatedAt: svc.UpdatedAt.String(),
ZitiServiceID: svc.ZitiServiceId, ZitiServiceID: svc.ZId,
ZrokServiceID: svc.ZrokServiceId, ZrokServiceID: svc.Name,
}) })
} }
out = append(out, es) out = append(out, es)

12
controller/store/service.go
View File

@ -8,19 +8,19 @@ import (
type Service struct { type Service struct {
Model Model
EnvironmentId int EnvironmentId int
ZitiServiceId string ZId string
ZrokServiceId string Name string
Frontend string Frontend string
Backend string Backend string
Active bool Active bool
} }
func (self *Store) CreateService(envId int, svc *Service, tx *sqlx.Tx) (int, error) { func (self *Store) CreateService(envId int, svc *Service, tx *sqlx.Tx) (int, error) {
stmt, err := tx.Prepare("insert into services (environment_id, ziti_service_id, zrok_service_id, frontend, backend, active) values (?, ?, ?, ?, ?, true)") stmt, err := tx.Prepare("insert into services (environment_id, z_id, name, frontend, backend, active) values (?, ?, ?, ?, ?, true)")
if err != nil { if err != nil {
return 0, errors.Wrap(err, "error preparing services insert statement") return 0, errors.Wrap(err, "error preparing services insert statement")
} }
res, err := stmt.Exec(envId, svc.ZitiServiceId, svc.ZrokServiceId, svc.Frontend, svc.Backend) res, err := stmt.Exec(envId, svc.ZId, svc.Name, svc.Frontend, svc.Backend)
if err != nil { if err != nil {
return 0, errors.Wrap(err, "error executing services insert statement") return 0, errors.Wrap(err, "error executing services insert statement")
} }
@ -72,12 +72,12 @@ func (self *Store) FindServicesForEnvironment(envId int, tx *sqlx.Tx) ([]*Servic
} }
func (self *Store) UpdateService(svc *Service, tx *sqlx.Tx) error { func (self *Store) UpdateService(svc *Service, tx *sqlx.Tx) error {
sql := "update services set ziti_service_id = ?, zrok_service_id = ?, frontend = ?, backend = ?, active = ?, updated_at = strftime('%Y-%m-%d %H:%M:%f', 'now') where id = ?" sql := "update services set z_id = ?, name = ?, frontend = ?, backend = ?, active = ?, updated_at = strftime('%Y-%m-%d %H:%M:%f', 'now') where id = ?"
stmt, err := tx.Prepare(sql) stmt, err := tx.Prepare(sql)
if err != nil { if err != nil {
return errors.Wrap(err, "error preparing services update statement") return errors.Wrap(err, "error preparing services update statement")
} }
_, err = stmt.Exec(svc.ZitiServiceId, svc.ZrokServiceId, svc.Frontend, svc.Backend, svc.Active, svc.Id) _, err = stmt.Exec(svc.ZId, svc.Name, svc.Frontend, svc.Backend, svc.Active, svc.Id)
if err != nil { if err != nil {
return errors.Wrap(err, "error executing services update statement") return errors.Wrap(err, "error executing services update statement")
} }

7
controller/store/sql/000_base.sql
View File

@ -51,13 +51,14 @@ create table environments (
create table services ( create table services (
id integer primary key, id integer primary key,
environment_id integer constraint fk_environments_services references environments on delete cascade, environment_id integer constraint fk_environments_services references environments on delete cascade,
ziti_service_id string not null unique, z_id string not null unique,
zrok_service_id string not null unique, name string not null unique,
frontend string, frontend string,
backend string, backend string,
active boolean not null, active boolean not null,
created_at datetime not null default(strftime('%Y-%m-%d %H:%M:%f', 'now')), created_at datetime not null default(strftime('%Y-%m-%d %H:%M:%f', 'now')),
updated_at datetime not null default(strftime('%Y-%m-%d %H:%M:%f', 'now')), updated_at datetime not null default(strftime('%Y-%m-%d %H:%M:%f', 'now')),
constraint chk_ziti_service_id check (ziti_service_id <> '') constraint chk_z_id check (z_id <> ''),
constraint chk_name check (name <> '')
); );

14
controller/tunnel.go
View File

@ -73,20 +73,20 @@ func (self *tunnelHandler) Handle(params tunnel.TunnelParams, principal *rest_mo
logrus.Error(err) logrus.Error(err)
return tunnel.NewTunnelInternalServerError() return tunnel.NewTunnelInternalServerError()
} }
svcId, err := self.createService(svcName, cfgId, edge) svcZId, err := self.createService(svcName, cfgId, edge)
if err != nil { if err != nil {
logrus.Error(err) logrus.Error(err)
return tunnel.NewTunnelInternalServerError() return tunnel.NewTunnelInternalServerError()
} }
if err := self.createServicePolicyBind(svcName, svcId, envId, edge); err != nil { if err := self.createServicePolicyBind(svcName, svcZId, envId, edge); err != nil {
logrus.Error(err) logrus.Error(err)
return tunnel.NewTunnelInternalServerError() return tunnel.NewTunnelInternalServerError()
} }
if err := self.createServicePolicyDial(svcName, svcId, edge); err != nil { if err := self.createServicePolicyDial(svcName, svcZId, edge); err != nil {
logrus.Error(err) logrus.Error(err)
return tunnel.NewTunnelInternalServerError() return tunnel.NewTunnelInternalServerError()
} }
if err := self.createServiceEdgeRouterPolicy(svcName, svcId, edge); err != nil { if err := self.createServiceEdgeRouterPolicy(svcName, svcZId, edge); err != nil {
logrus.Error(err) logrus.Error(err)
return tunnel.NewTunnelInternalServerError() return tunnel.NewTunnelInternalServerError()
} }
@ -95,8 +95,8 @@ func (self *tunnelHandler) Handle(params tunnel.TunnelParams, principal *rest_mo
frontendUrl := self.proxyUrl(svcName) frontendUrl := self.proxyUrl(svcName)
sid, err := str.CreateService(envIdDb, &store.Service{ sid, err := str.CreateService(envIdDb, &store.Service{
ZitiServiceId: svcId, ZId: svcZId,
ZrokServiceId: svcName, Name: svcName,
Frontend: frontendUrl, Frontend: frontendUrl,
Backend: params.Body.Endpoint, Backend: params.Body.Endpoint,
}, tx) }, tx)
@ -109,7 +109,7 @@ func (self *tunnelHandler) Handle(params tunnel.TunnelParams, principal *rest_mo
logrus.Errorf("error committing service record: %v", err) logrus.Errorf("error committing service record: %v", err)
return tunnel.NewTunnelInternalServerError() return tunnel.NewTunnelInternalServerError()
} }
logrus.Infof("recorded service '%v' with id '%v' for '%v'", svcId, sid, principal.Email) logrus.Infof("recorded service '%v' with id '%v' for '%v'", svcZId, sid, principal.Email)
return tunnel.NewTunnelCreated().WithPayload(&rest_model_zrok.TunnelResponse{ return tunnel.NewTunnelCreated().WithPayload(&rest_model_zrok.TunnelResponse{
ProxyEndpoint: frontendUrl, ProxyEndpoint: frontendUrl,

12
controller/untunnel.go
View File

@ -38,7 +38,7 @@ func (self *untunnelHandler) Handle(params tunnel.UntunnelParams, principal *res
return tunnel.NewUntunnelInternalServerError() return tunnel.NewUntunnelInternalServerError()
} }
svcName := params.Body.Service svcName := params.Body.Service
svcId, err := self.findServiceId(svcName, edge) svcZId, err := self.findServiceZId(svcName, edge)
if err != nil { if err != nil {
logrus.Error(err) logrus.Error(err)
return tunnel.NewUntunnelInternalServerError() return tunnel.NewUntunnelInternalServerError()
@ -64,13 +64,13 @@ func (self *untunnelHandler) Handle(params tunnel.UntunnelParams, principal *res
var ssvc *store.Service var ssvc *store.Service
if svcs, err := str.FindServicesForEnvironment(senv.Id, tx); err == nil { if svcs, err := str.FindServicesForEnvironment(senv.Id, tx); err == nil {
for _, svc := range svcs { for _, svc := range svcs {
if svc.ZitiServiceId == svcId { if svc.ZId == svcZId {
ssvc = svc ssvc = svc
break break
} }
} }
if ssvc == nil { if ssvc == nil {
err := errors.Errorf("service with id '%v' not found for '%v'", svcId, principal.Email) err := errors.Errorf("service with id '%v' not found for '%v'", svcZId, principal.Email)
logrus.Error(err) logrus.Error(err)
return tunnel.NewUntunnelNotFound() return tunnel.NewUntunnelNotFound()
} }
@ -95,7 +95,7 @@ func (self *untunnelHandler) Handle(params tunnel.UntunnelParams, principal *res
logrus.Error(err) logrus.Error(err)
return tunnel.NewTunnelInternalServerError() return tunnel.NewTunnelInternalServerError()
} }
if err := deleteService(svcId, edge); err != nil { if err := deleteService(svcZId, edge); err != nil {
logrus.Error(err) logrus.Error(err)
return tunnel.NewUntunnelInternalServerError() return tunnel.NewUntunnelInternalServerError()
} }
@ -104,7 +104,7 @@ func (self *untunnelHandler) Handle(params tunnel.UntunnelParams, principal *res
ssvc.Active = false ssvc.Active = false
if err := str.UpdateService(ssvc, tx); err != nil { if err := str.UpdateService(ssvc, tx); err != nil {
logrus.Errorf("error deactivating service '%v': %v", svcId, err) logrus.Errorf("error deactivating service '%v': %v", svcZId, err)
return tunnel.NewUntunnelInternalServerError() return tunnel.NewUntunnelInternalServerError()
} }
if err := tx.Commit(); err != nil { if err := tx.Commit(); err != nil {
@ -115,7 +115,7 @@ func (self *untunnelHandler) Handle(params tunnel.UntunnelParams, principal *res
return tunnel.NewUntunnelOK() return tunnel.NewUntunnelOK()
} }
func (_ *untunnelHandler) findServiceId(svcName string, edge *rest_management_api_client.ZitiEdgeManagement) (string, error) { func (_ *untunnelHandler) findServiceZId(svcName string, edge *rest_management_api_client.ZitiEdgeManagement) (string, error) {
filter := fmt.Sprintf("name=\"%v\"", svcName) filter := fmt.Sprintf("name=\"%v\"", svcName)
limit := int64(1) limit := int64(1)
offset := int64(0) offset := int64(0)