Scale set workers properly come online

This adds the workers needed to start listening for scale set messages.
There is no handling of messages yet.

Signed-off-by: Gabriel Adrian Samfira <gsamfira@cloudbasesolutions.com>

database/sql/models.go

@@ -136,6 +136,17 @@ type ScaleSet struct {
 	Instances []Instance `gorm:"foreignKey:ScaleSetFkID"`
 }
 
+type RepositoryEvent struct {
+	gorm.Model
+
+	EventType  params.EventType
+	EventLevel params.EventLevel
+	Message    string `gorm:"type:text"`
+
+	RepoID uuid.UUID  `gorm:"index:idx_repo_event"`
+	Repo   Repository `gorm:"foreignKey:RepoID"`
+}
+
 type Repository struct {
 	Base
 
@@ -154,8 +165,20 @@ type Repository struct {
 
 	EndpointName *string        `gorm:"index:idx_owner_nocase,unique,collate:nocase"`
 	Endpoint     GithubEndpoint `gorm:"foreignKey:EndpointName;constraint:OnDelete:SET NULL"`
+
+	Events []RepositoryEvent `gorm:"foreignKey:RepoID;constraint:OnDelete:CASCADE,OnUpdate:CASCADE;"`
 }
 
+type OrganizationEvent struct {
+	gorm.Model
+
+	EventType  params.EventType
+	EventLevel params.EventLevel
+	Message    string `gorm:"type:text"`
+
+	OrgID uuid.UUID    `gorm:"index:idx_org_event"`
+	Org   Organization `gorm:"foreignKey:OrgID"`
+}
 type Organization struct {
 	Base
 
@@ -173,6 +196,19 @@ type Organization struct {
 
 	EndpointName *string        `gorm:"index:idx_org_name_nocase,collate:nocase"`
 	Endpoint     GithubEndpoint `gorm:"foreignKey:EndpointName;constraint:OnDelete:SET NULL"`
+
+	Events []OrganizationEvent `gorm:"foreignKey:OrgID;constraint:OnDelete:CASCADE,OnUpdate:CASCADE;"`
+}
+
+type EnterpriseEvent struct {
+	gorm.Model
+
+	EventType  params.EventType
+	EventLevel params.EventLevel
+	Message    string `gorm:"type:text"`
+
+	EnterpriseID uuid.UUID  `gorm:"index:idx_enterprise_event"`
+	Enterprise   Enterprise `gorm:"foreignKey:EnterpriseID"`
 }
 
 type Enterprise struct {
@@ -192,6 +228,8 @@ type Enterprise struct {
 
 	EndpointName *string        `gorm:"index:idx_ent_name_nocase,collate:nocase"`
 	Endpoint     GithubEndpoint `gorm:"foreignKey:EndpointName;constraint:OnDelete:SET NULL"`
+
+	Events []EnterpriseEvent `gorm:"foreignKey:EnterpriseID;constraint:OnDelete:CASCADE,OnUpdate:CASCADE;"`
 }
 
 type Address struct {

database/sql/sql.go

@@ -423,6 +423,9 @@ func (s *sqlDatabase) migrateDB() error {
 		&Repository{},
 		&Organization{},
 		&Enterprise{},
+		&EnterpriseEvent{},
+		&OrganizationEvent{},
+		&RepositoryEvent{},
 		&Address{},
 		&InstanceStatusUpdate{},
 		&Instance{},

database/sql/util.go

@@ -631,3 +631,136 @@ func (s *sqlDatabase) GetGithubEntity(_ context.Context, entityType params.Githu
 	}
 	return entity, nil
 }
+
+func (s *sqlDatabase) addRepositoryEvent(ctx context.Context, repoID string, event params.EventType, eventLevel params.EventLevel, statusMessage string, maxEvents int) error {
+	repo, err := s.GetRepositoryByID(ctx, repoID)
+	if err != nil {
+		return errors.Wrap(err, "updating instance")
+	}
+
+	msg := InstanceStatusUpdate{
+		Message:    statusMessage,
+		EventType:  event,
+		EventLevel: eventLevel,
+	}
+
+	if err := s.conn.Model(&repo).Association("Events").Append(&msg); err != nil {
+		return errors.Wrap(err, "adding status message")
+	}
+
+	if maxEvents > 0 {
+		repoID, err := uuid.Parse(repo.ID)
+		if err != nil {
+			return errors.Wrap(runnerErrors.ErrBadRequest, "parsing id")
+		}
+		var latestEvents []OrganizationEvent
+		q := s.conn.Model(&OrganizationEvent{}).
+			Limit(maxEvents).Order("id desc").
+			Where("repo_id = ?", repoID).Find(&latestEvents)
+		if q.Error != nil {
+			return errors.Wrap(q.Error, "fetching latest events")
+		}
+		if len(latestEvents) == maxEvents {
+			lastInList := latestEvents[len(latestEvents)-1]
+			if err := s.conn.Where("repo_id = ? and id < ?", repoID, lastInList.ID).Unscoped().Delete(&OrganizationEvent{}).Error; err != nil {
+				return errors.Wrap(err, "deleting old events")
+			}
+		}
+	}
+	return nil
+}
+
+func (s *sqlDatabase) addOrgEvent(ctx context.Context, orgID string, event params.EventType, eventLevel params.EventLevel, statusMessage string, maxEvents int) error {
+	org, err := s.GetOrganizationByID(ctx, orgID)
+	if err != nil {
+		return errors.Wrap(err, "updating instance")
+	}
+
+	msg := InstanceStatusUpdate{
+		Message:    statusMessage,
+		EventType:  event,
+		EventLevel: eventLevel,
+	}
+
+	if err := s.conn.Model(&org).Association("Events").Append(&msg); err != nil {
+		return errors.Wrap(err, "adding status message")
+	}
+
+	if maxEvents > 0 {
+		orgID, err := uuid.Parse(org.ID)
+		if err != nil {
+			return errors.Wrap(runnerErrors.ErrBadRequest, "parsing id")
+		}
+		var latestEvents []OrganizationEvent
+		q := s.conn.Model(&OrganizationEvent{}).
+			Limit(maxEvents).Order("id desc").
+			Where("org_id = ?", orgID).Find(&latestEvents)
+		if q.Error != nil {
+			return errors.Wrap(q.Error, "fetching latest events")
+		}
+		if len(latestEvents) == maxEvents {
+			lastInList := latestEvents[len(latestEvents)-1]
+			if err := s.conn.Where("org_id = ? and id < ?", orgID, lastInList.ID).Unscoped().Delete(&OrganizationEvent{}).Error; err != nil {
+				return errors.Wrap(err, "deleting old events")
+			}
+		}
+	}
+	return nil
+}
+
+func (s *sqlDatabase) addEnterpriseEvent(ctx context.Context, entID string, event params.EventType, eventLevel params.EventLevel, statusMessage string, maxEvents int) error {
+	ent, err := s.GetEnterpriseByID(ctx, entID)
+	if err != nil {
+		return errors.Wrap(err, "updating instance")
+	}
+
+	msg := InstanceStatusUpdate{
+		Message:    statusMessage,
+		EventType:  event,
+		EventLevel: eventLevel,
+	}
+
+	if err := s.conn.Model(&ent).Association("Events").Append(&msg); err != nil {
+		return errors.Wrap(err, "adding status message")
+	}
+
+	if maxEvents > 0 {
+		entID, err := uuid.Parse(ent.ID)
+		if err != nil {
+			return errors.Wrap(runnerErrors.ErrBadRequest, "parsing id")
+		}
+		var latestEvents []EnterpriseEvent
+		q := s.conn.Model(&EnterpriseEvent{}).
+			Limit(maxEvents).Order("id desc").
+			Where("enterprise_id = ?", entID).Find(&latestEvents)
+		if q.Error != nil {
+			return errors.Wrap(q.Error, "fetching latest events")
+		}
+		if len(latestEvents) == maxEvents {
+			lastInList := latestEvents[len(latestEvents)-1]
+			if err := s.conn.Where("enterprise_id = ? and id < ?", entID, lastInList.ID).Unscoped().Delete(&EnterpriseEvent{}).Error; err != nil {
+				return errors.Wrap(err, "deleting old events")
+			}
+		}
+	}
+
+	return nil
+}
+
+func (s *sqlDatabase) AddEntityEvent(ctx context.Context, entity params.GithubEntity, event params.EventType, eventLevel params.EventLevel, statusMessage string, maxEvents int) error {
+	if maxEvents == 0 {
+		return errors.Wrap(runnerErrors.ErrBadRequest, "max events cannot be 0")
+	}
+	// TODO(gabriel-samfira): Should we send watcher notifications for events?
+	// Not sure it's of any value.
+	switch entity.EntityType {
+	case params.GithubEntityTypeRepository:
+		return s.addRepositoryEvent(ctx, entity.ID, event, eventLevel, statusMessage, maxEvents)
+	case params.GithubEntityTypeOrganization:
+		return s.addOrgEvent(ctx, entity.ID, event, eventLevel, statusMessage, maxEvents)
+	case params.GithubEntityTypeEnterprise:
+		return s.addEnterpriseEvent(ctx, entity.ID, event, eventLevel, statusMessage, maxEvents)
+	default:
+		return errors.Wrap(runnerErrors.ErrBadRequest, "invalid entity type")
+	}
+}