extern/zrok
1
1
Fork 0
mirror of https://github.com/openziti/zrok.git synced 2024-11-25 09:33:43 +01:00
Code Issues Packages Projects Releases Wiki Activity

record service activate/deactivate (#10)

Browse Source
This commit is contained in:
Michael Quigley 2022-07-29 16:21:47 -04:00
parent 2ae1ff06c4
commit 4080e219a3
No known key found for this signature in database
GPG Key ID: 9B60314A9DD20A62
5 changed files with 59 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
controller/store/identity.go
View File

@ -9,10 +9,11 @@ type Identity struct {
Model
AccountId int
ZitiId string
Active bool
}
func (self *Store) CreateIdentity(accountId int, i *Identity, tx *sqlx.Tx) (int, error) {
stmt, err := tx.Prepare("insert into identities (account_id, ziti_id) values (?, ?)")
stmt, err := tx.Prepare("insert into identities (account_id, ziti_id, active) values (?, ?, true)")
if err != nil {
return 0, errors.Wrap(err, "error preparing identities insert statement")
}

15
controller/store/service.go
View File

@ -10,10 +10,11 @@ type Service struct {
AccountId int
ZitiId string
Endpoint string
Active bool
}
func (self *Store) CreateService(accountId int, svc *Service, tx *sqlx.Tx) (int, error) {
stmt, err := tx.Prepare("insert into services (account_id, ziti_id, endpoint) values (?, ?, ?)")
stmt, err := tx.Prepare("insert into services (account_id, ziti_id, endpoint, active) values (?, ?, ?, true)")
if err != nil {
return 0, errors.Wrap(err, "error preparing services insert statement")
}
@ -52,6 +53,18 @@ func (self *Store) FindServicesForAccount(accountId int, tx *sqlx.Tx) ([]*Servic
return svcs, nil
}
func (self *Store) DeactivateService(id int, tx *sqlx.Tx) error {
stmt, err := tx.Prepare("update services set active=false where id = ?")
if err != nil {
return errors.Wrap(err, "error preparing services deactivate statement")
}
_, err = stmt.Exec(id)
if err != nil {
return errors.Wrap(err, "error executing services deactivate statement")
}
return nil
}
func (self *Store) DeleteService(id int, tx *sqlx.Tx) error {
stmt, err := tx.Prepare("delete from services where id = ?")
if err != nil {

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

@ -23,6 +23,7 @@ create table identities (
id integer primary key,
account_id integer constraint fk_accounts_identities references accounts on delete cascade,
ziti_id string not null unique,
active boolean not null,
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')),
@ -37,6 +38,7 @@ create table services (
account_id integer constraint fk_accounts_services references accounts on delete cascade,
ziti_id string not null unique,
endpoint string,
active boolean not null,
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')),

1
controller/tunnel.go
View File

@ -25,6 +25,7 @@ func tunnelHandler(params tunnel.TunnelParams, principal *rest_model_zrok.Princi
logrus.Errorf("error starting transaction: %v", err)
return tunnel.NewTunnelInternalServerError().WithPayload(rest_model_zrok.ErrorMessage(err.Error()))
}
defer func() { _ = tx.Rollback() }()
edge, err := edgeClient()
if err != nil {

48
controller/untunnel.go
View File

@ -17,35 +17,62 @@ import (
func untunnelHandler(params tunnel.UntunnelParams, principal *rest_model_zrok.Principal) middleware.Responder {
logrus.Infof("untunneling for '%v' (%v)", principal.Username, principal.Token)
edge, err := edgeClient()
if err != nil {
logrus.Error(err)
return tunnel.NewUntunnelInternalServerError()
return tunnel.NewUntunnelInternalServerError().WithPayload(rest_model_zrok.ErrorMessage(err.Error()))
}
svcName := params.Body.Service
if err := deleteEdgeRouterPolicy(svcName, edge); err != nil {
logrus.Error(err)
return tunnel.NewUntunnelInternalServerError()
return tunnel.NewUntunnelInternalServerError().WithPayload(rest_model_zrok.ErrorMessage(err.Error()))
}
if err := deleteServiceEdgeRouterPolicy(svcName, edge); err != nil {
logrus.Error(err)
return tunnel.NewUntunnelInternalServerError()
return tunnel.NewUntunnelInternalServerError().WithPayload(rest_model_zrok.ErrorMessage(err.Error()))
}
if err := deleteServicePolicyDial(svcName, edge); err != nil {
logrus.Error(err)
return tunnel.NewUntunnelInternalServerError()
return tunnel.NewUntunnelInternalServerError().WithPayload(rest_model_zrok.ErrorMessage(err.Error()))
}
if err := deleteServicePolicyBind(svcName, edge); err != nil {
logrus.Error(err)
return tunnel.NewUntunnelInternalServerError()
return tunnel.NewUntunnelInternalServerError().WithPayload(rest_model_zrok.ErrorMessage(err.Error()))
}
if err := deleteService(svcName, edge); err != nil {
svcId, err := deleteService(svcName, edge)
if err != nil {
logrus.Error(err)
return tunnel.NewUntunnelInternalServerError().WithPayload(rest_model_zrok.ErrorMessage(err.Error()))
}
logrus.Infof("deallocated service '%v'", svcName)
tx, err := str.Begin()
if err != nil {
logrus.Errorf("error starting transaction: %v", err)
return tunnel.NewUntunnelInternalServerError().WithPayload(rest_model_zrok.ErrorMessage(err.Error()))
}
defer func() { _ = tx.Rollback() }()
svcs, err := str.FindServicesForAccount(int(principal.ID), tx)
if err != nil {
logrus.Errorf("error finding services for account: %v", err)
return tunnel.NewUntunnelInternalServerError().WithPayload(rest_model_zrok.ErrorMessage(err.Error()))
}
for _, svc := range svcs {
if svc.ZitiId == svcId {
if err := str.DeactivateService(svc.Id, tx); err != nil {
logrus.Errorf("error deactivating service '%v': %v", svcId, err)
return tunnel.NewUntunnelInternalServerError().WithPayload(rest_model_zrok.ErrorMessage(err.Error()))
}
if err := tx.Commit(); err != nil {
logrus.Errorf("error committing: %v", err)
return tunnel.NewUntunnelInternalServerError().WithPayload(rest_model_zrok.ErrorMessage(err.Error()))
}
logrus.Infof("deactivated service '%v'", svcId)
}
}
return tunnel.NewUntunnelOK()
}
@ -155,7 +182,7 @@ func deleteServicePolicy(filter string, edge *rest_management_api_client.ZitiEdg
return nil
}
func deleteService(svcName string, edge *rest_management_api_client.ZitiEdgeManagement) error {
func deleteService(svcName string, edge *rest_management_api_client.ZitiEdgeManagement) (string, error) {
filter := fmt.Sprintf("name=\"%v\"", svcName)
limit := int64(1)
offset := int64(0)
@ -168,7 +195,7 @@ func deleteService(svcName string, edge *rest_management_api_client.ZitiEdgeMana
listReq.SetTimeout(30 * time.Second)
listResp, err := edge.Service.ListServices(listReq, nil)
if err != nil {
return err
return "", err
}
if len(listResp.Payload.Data) == 1 {
svcId := *(listResp.Payload.Data[0].ID)
@ -179,11 +206,12 @@ func deleteService(svcName string, edge *rest_management_api_client.ZitiEdgeMana
req.SetTimeout(30 * time.Second)
_, err := edge.Service.DeleteService(req, nil)
if err != nil {
return err
return "", err
}
logrus.Infof("deleted service '%v'", svcId)
return svcId, nil
} else {
logrus.Infof("did not find a service")
}
return nil
return "", nil
}