Add Auto Role Feature

Add action to deploy to ECS after image is built

.github/workflows/main.yml

@@ -17,28 +17,36 @@ jobs:
       # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
       - uses: actions/checkout@v2
       
-      - name: Configure AWS credentials
-        uses: aws-actions/configure-aws-credentials@v1
-        with:
-          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
-          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
-          aws-region: us-east-1
-
-      - name: Login to Amazon ECR
-        id: login-ecr
-        uses: aws-actions/amazon-ecr-login@v1
-      
       - name: Get Version
         id: get_version
         uses: battila7/get-version-action@v2.0.0
 
-      - name: Build, tag, and push image to Amazon ECR
+      - name: Build container image
         env:
-          ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
-          ECR_REPOSITORY: goff
           IMAGE_TAG: ${{ steps.get_version.outputs.version-without-v }}
-        run: |
+        run: docker build -t registry.digitalocean.com/djpianalto/goff:$IMAGE_TAG .
-          docker build -t $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG .
+
-          docker push $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG
+      - name: Install doctl
-          docker tag $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG $ECR_REGISTRY/$ECR_REPOSITORY:latest
+        uses: digitalocean/action-doctl@v2
-          docker push $ECR_REGISTRY/$ECR_REPOSITORY:latest
+        with:
+          token: ${{ secrets.DIGITALOCEAN_ACCESS_TOKEN }}
+
+      - name: Login to DigitalOcean Container Registry with short-lived credentials
+        run: doctl registry login --expiry-seconds 600
+
+      - name: Push image to DigitalOcean Container Registry
+        env:
+          IMAGE_TAG: ${{ steps.get_version.outputs.version-without-v }}
+        run: docker push registry.digitalocean.com/djpianalto/goff:$IMAGE_TAG
+
+      - name: Update deployment file
+        run: TAG=${{ steps.get_version.outputs.version-without-v }} && sed -i 's|<IMAGE>|registry.digitalocean.com/djpianalto/goff:'${TAG}'|' $GITHUB_WORKSPACE/deployment.yml
+
+      - name: Save DigitalOcean kubeconfig with short-lived credentials
+        run: doctl kubernetes cluster kubeconfig save --expiry-seconds 600 discord-bots
+
+      - name: Deploy to DigitalOcean Kubernetes
+        run: kubectl apply -f $GITHUB_WORKSPACE/deployment.yml
+
+      - name: Verify deployment
+        run: kubectl rollout status deployment/goff

cmd/goff/main.go

@@ -51,6 +51,7 @@ func main() {
 
 	us := &postgres.UserService{DB: postgres.DB}
 	gs := &postgres.GuildService{DB: postgres.DB}
+	rs := &postgres.RoleService{DB: postgres.DB}
 
 	//prefixes := []string{
 	//	"Go.",
@@ -71,7 +72,7 @@ func main() {
 
 	// Add Command Handlers
 	exts.AddCommandHandlers(&manager)
-	services.InitalizeServices(us, gs)
+	services.InitalizeServices(us, gs, rs)
 
 	//if _, ok := handler.Commands["help"]; !ok {
 	//	handler.AddDefaultHelpCommand()

deployment.yml

@@ -0,0 +1,46 @@
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: goff
+  namespace: default
+  labels:
+    app: goff
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: goff
+  strategy:
+    rollingUpdate:
+      maxSurge: 1
+      maxUnavailable: 1
+  minReadySeconds: 120
+  template:
+    metadata:
+      labels:
+        app: goff
+    spec:
+      containers:
+        - name: goff
+          image: <IMAGE>
+          env:
+            - name: DATABASE_URL
+              valueFrom:
+                secretKeyRef:
+                  name: goff
+                  key: database_url
+            - name: DISCORDGO_TOKEN
+              valueFrom:
+                secretKeyRef:
+                  name: goff
+                  key: discord_token
+            - name: GOFF_EMAIL_USERNAME
+              valueFrom:
+                secretKeyRef:
+                  name: goff
+                  key: email_username
+            - name: GOFF_EMAIL_PASSWORD
+              valueFrom:
+                secretKeyRef:
+                  name: goff
+                  key: email_password

internal/exts/init.go

@@ -34,6 +34,8 @@ func AddCommandHandlers(h *disgoman.CommandManager) {
 	_ = h.AddCommand(roles.RemoveSelfAssignableCommand)
 	_ = h.AddCommand(roles.SelfAssignRoleCommand)
 	_ = h.AddCommand(roles.UnAssignRoleCommand)
+	_ = h.AddCommand(roles.MakeAutoRoleCommand)
+	_ = h.AddCommand(roles.RemoveAutoRoleCommand)
 	_ = h.AddCommand(p_interpreter.PCommand)
 	_ = h.AddCommand(fun.InterleaveCommand)
 	_ = h.AddCommand(fun.DeinterleaveCommand)

internal/exts/roles/roles.go

@@ -7,7 +7,9 @@ import (
 
 	"github.com/bwmarrin/discordgo"
 	"github.com/dustinpianalto/disgoman"
+	"github.com/dustinpianalto/goff"
 	"github.com/dustinpianalto/goff/internal/postgres"
+	"github.com/dustinpianalto/goff/internal/services"
 )
 
 var MakeRoleSelfAssignableCommand = &disgoman.Command{
@@ -254,3 +256,134 @@ func memberHasRole(m *discordgo.Member, id string) bool {
 	}
 	return false
 }
+
+var MakeAutoRoleCommand = &disgoman.Command{
+	Name:                "make-auto-role",
+	Aliases:             []string{"makear"},
+	Description:         "Marks the passed in role to auto add to new members.",
+	OwnerOnly:           false,
+	Hidden:              false,
+	RequiredPermissions: disgoman.PermissionManageServer,
+	Invoke:              makeAutoRoleCommandFunc,
+}
+
+func makeAutoRoleCommandFunc(ctx disgoman.Context, args []string) {
+	var roleString string
+	var roleID string
+	if len(args) > 0 {
+		roleString = strings.Join(args, " ")
+		if strings.HasPrefix(roleString, "<@&") && strings.HasSuffix(roleString, ">") {
+			roleID = roleString[3 : len(roleString)-1]
+		} else if _, err := strconv.Atoi(roleString); err == nil {
+			roleID = roleString
+		} else {
+			for _, role := range ctx.Guild.Roles {
+				if roleString == role.Name {
+					roleID = role.ID
+				}
+			}
+		}
+	}
+	fmt.Println(roleID)
+	var r *discordgo.Role
+	var err error
+	if r, err = ctx.Session.State.Role(ctx.Guild.ID, roleID); err != nil {
+		ctx.CommandManager.ErrorChannel <- disgoman.CommandError{
+			Context: ctx,
+			Message: "Can't find that Role.",
+			Error:   err,
+		}
+		return
+	}
+	role, err := services.RoleService.Role(r.ID)
+	if err != nil {
+		role = &goff.Role{
+			ID:             r.ID,
+			IsModerator:    false,
+			IsAdmin:        false,
+			SelfAssignable: false,
+			AutoRole:       true,
+			Guild:          ctx.Guild.ID,
+		}
+		role, err = services.RoleService.AddRole(role)
+		if err != nil {
+			ctx.CommandManager.ErrorChannel <- disgoman.CommandError{
+				Context: ctx,
+				Message: "Error making an Auto Role",
+				Error:   err,
+			}
+			return
+		}
+	} else {
+		err = services.RoleService.MakeAutoRole(role)
+		if err != nil {
+			ctx.CommandManager.ErrorChannel <- disgoman.CommandError{
+				Context: ctx,
+				Message: "Error making an Auto Role",
+				Error:   err,
+			}
+			return
+		}
+	}
+
+}
+
+var RemoveAutoRoleCommand = &disgoman.Command{
+	Name:                "remove-auto-role",
+	Aliases:             []string{"removear"},
+	Description:         "Remove role from those added to new members.",
+	OwnerOnly:           false,
+	Hidden:              false,
+	RequiredPermissions: disgoman.PermissionManageServer,
+	Invoke:              removeAutoRoleCommandFunc,
+}
+
+func removeAutoRoleCommandFunc(ctx disgoman.Context, args []string) {
+	var roleString string
+	var roleID string
+	if len(args) > 0 {
+		roleString = strings.Join(args, " ")
+		if strings.HasPrefix(roleString, "<@&") && strings.HasSuffix(roleString, ">") {
+			roleID = roleString[3 : len(roleString)-1]
+		} else if _, err := strconv.Atoi(roleString); err == nil {
+			roleID = roleString
+		} else {
+			for _, role := range ctx.Guild.Roles {
+				if roleString == role.Name {
+					roleID = role.ID
+				}
+			}
+		}
+	}
+	fmt.Println(roleID)
+	var r *discordgo.Role
+	var err error
+	if r, err = ctx.Session.State.Role(ctx.Guild.ID, roleID); err != nil {
+		ctx.CommandManager.ErrorChannel <- disgoman.CommandError{
+			Context: ctx,
+			Message: "Can't find that Role.",
+			Error:   err,
+		}
+		return
+	}
+	role, err := services.RoleService.Role(r.ID)
+	if err != nil {
+		ctx.CommandManager.ErrorChannel <- disgoman.CommandError{
+			Context: ctx,
+			Message: "Role was not configured as an Auto Role",
+			Error:   err,
+		}
+		return
+	} else {
+		err = services.RoleService.RemoveAutoRole(role)
+		if err != nil {
+			ctx.CommandManager.ErrorChannel <- disgoman.CommandError{
+				Context: ctx,
+				Message: "Error removing Auto Role",
+				Error:   err,
+			}
+			return
+		}
+	}
+
+}

internal/exts/tags/tags.go

@@ -7,7 +7,9 @@ import (
 	"strings"
 
 	"github.com/dustinpianalto/disgoman"
+	"github.com/dustinpianalto/goff"
 	"github.com/dustinpianalto/goff/internal/postgres"
+	"github.com/dustinpianalto/goff/internal/services"
 )
 
 var AddTagCommand = &disgoman.Command{
@@ -55,6 +57,10 @@ func addTagCommandFunc(ctx disgoman.Context, input []string) {
 				}
 				return
 			}
+			err = services.UserService.CreateUser(&goff.User{ID: ctx.User.ID}, ctx.Guild.ID)
+			if err != nil {
+				log.Printf("Error creating user %s: %s", ctx.User.ID, err.Error())
+			}
 			queryString = `INSERT INTO tags (tag, content, creator, guild_id) VALUES ($1, $2, $3, $4);`
 			_, err := postgres.DB.Exec(queryString, tag, value, ctx.Message.Author.ID, ctx.Guild.ID)
 			if err != nil {

internal/exts/user_management/member_join.go

@@ -25,7 +25,7 @@ func OnGuildMemberAdd(s *discordgo.Session, member *discordgo.GuildMemberAdd) {
 			IsStaff:  false,
 			IsAdmin:  false,
 		}
-		err := services.UserService.CreateUser(user)
+		err := services.UserService.CreateUser(user, member.GuildID)
 		if err != nil {
 			log.Println("Error adding user to database: ", err)
 		}
@@ -41,6 +41,22 @@ func OnGuildMemberAdd(s *discordgo.Session, member *discordgo.GuildMemberAdd) {
 	if err != nil {
 		log.Println("Error adding user to guild: ", err)
 	}
+	roles, err := services.RoleService.GetAutoRoles(member.GuildID)
+	if err != nil {
+		log.Println("Error getting Auto Join Roles: ", err)
+	}
+	for _, r := range roles {
+		role, err := s.State.Role(member.GuildID, r.ID)
+		if err != nil {
+			log.Println("Error getting role: ", err)
+			continue
+		}
+		err = s.GuildMemberRoleAdd(member.GuildID, member.User.ID, role.ID)
+		if err != nil {
+			log.Println("Error adding Role to member: ", err)
+			continue
+		}
+	}
 }
 
 func OnGuildMemberRemove(s *discordgo.Session, member *discordgo.GuildMemberRemove) {

internal/postgres/postfixes.go

@@ -32,6 +32,10 @@ var postfixes = []postfix{
 		Name:   "4_Add_Multi_Column_Unique_XUsersGuilds",
 		Invoke: addMultiColumnUniqueXUsersGuilds,
 	},
+	postfix{
+		Name:   "5_Add_Auto_Role_To_Roles_Table",
+		Invoke: addAutoRoleToRoles,
+	},
 }
 
 func RunPostfixes() {
@@ -162,3 +166,20 @@ func addMultiColumnUniqueXUsersGuilds(revert bool) error {
 	}
 	return nil
 }
+
+func addAutoRoleToRoles(revert bool) error {
+	var queryString string
+	if !revert {
+		queryString = `ALTER TABLE roles
+						ADD COLUMN auto_role bool DEFAULT false`
+	} else {
+		queryString = `ALTER TABLE roles
+						DROP COLUMN auto_role`
+	}
+	_, err := DB.Exec(queryString)
+	if err != nil {
+		log.Println(err)
+		return err
+	}
+	return nil
+}

internal/postgres/roles.go

@@ -0,0 +1,86 @@
+package postgres
+
+import (
+	"database/sql"
+	"log"
+
+	"github.com/dustinpianalto/goff"
+)
+
+type RoleService struct {
+	DB *sql.DB
+}
+
+func (s *RoleService) Role(id string) (*goff.Role, error) {
+	var r goff.Role
+	queryString := `SELECT id, moderator, admin, self_assignable, guild_id FROM roles WHERE id = $1`
+	row := s.DB.QueryRow(queryString, id)
+	if err := row.Scan(&r.ID, &r.IsModerator, &r.IsAdmin, &r.SelfAssignable, &r.Guild); err != nil {
+		return nil, err
+	}
+	return &r, nil
+}
+
+func (s *RoleService) AddRole(r *goff.Role) (*goff.Role, error) {
+	queryString := `INSERT INTO roles (id, moderator, admin, self_assignable, auto_role, guild)
+						VALUES ($1, $2, $3, $4, $5, $6) ON CONFLICT DO NOTHING`
+	_, err := s.DB.Exec(queryString, r.ID, r.IsModerator, r.IsAdmin, r.SelfAssignable, r.AutoRole, r.Guild)
+	if err != nil {
+		return nil, err
+	}
+	return r, nil
+}
+
+func (s *RoleService) DeleteRole(r *goff.Role) error {
+	queryString := `DELETE FROM roles WHERE id = $1`
+	_, err := s.DB.Exec(queryString, r.ID)
+	return err
+}
+
+func (s *RoleService) MakeSelfAssignable(r *goff.Role) error {
+	queryString := `UPDATE roles SET self_assignable = true WHERE id = $1`
+	_, err := s.DB.Exec(queryString, r.ID)
+	return err
+}
+
+func (s *RoleService) RemoveSelfAssignable(r *goff.Role) error {
+	queryString := `UPDATE roles SET self_assignable = false WHERE id = $1`
+	_, err := s.DB.Exec(queryString, r.ID)
+	return err
+}
+
+func (s *RoleService) MakeAutoRole(r *goff.Role) error {
+	queryString := `UPDATE roles SET auto_role = true WHERE id = $1`
+	_, err := s.DB.Exec(queryString, r.ID)
+	return err
+}
+
+func (s *RoleService) RemoveAutoRole(r *goff.Role) error {
+	queryString := `UPDATE roles SET auto_role = false WHERE id = $1`
+	_, err := s.DB.Exec(queryString, r.ID)
+	return err
+}
+
+func (s *RoleService) GetAutoRoles(gID string) ([]*goff.Role, error) {
+	var roles []*goff.Role
+	queryString := `SELECT id FROM roles WHERE guild_id = $1`
+	rows, err := s.DB.Query(queryString, gID)
+	if err != nil {
+		return nil, err
+	}
+	for rows.Next() {
+		var id string
+		err := rows.Scan(&id)
+		if err != nil {
+			log.Println(err)
+			continue
+		}
+		role, err := s.Role(id)
+		if err != nil {
+			log.Println(err)
+			continue
+		}
+		roles = append(roles, role)
+	}
+	return roles, nil
+}

internal/postgres/user.go

@@ -36,10 +36,13 @@ func (s *UserService) User(id string) (*goff.User, error) {
 	return &u, nil
 }
 
-func (s *UserService) CreateUser(u *goff.User) error {
+func (s *UserService) CreateUser(u *goff.User, gid string) error {
 	queryString := `INSERT INTO users (id, banned, logging, steam_id, is_active, is_staff, is_admin)
-						VALUES ($1, $2, $3, $4, $5, $6, $7)`
+						VALUES ($1, $2, $3, $4, $5, $6, $7) ON CONFLICT DO NOTHING`
 	_, err := s.DB.Exec(queryString, u.ID, u.Banned, u.Logging, u.SteamID, u.IsActive, u.IsStaff, u.IsAdmin)
+	if err == nil {
+		err = s.AddUserToGuild(u, &goff.Guild{ID: gid})
+	}
 	return err
 }
 
@@ -59,7 +62,7 @@ func (s *UserService) MarkUserInactive(u *goff.User) error {
 }
 
 func (s *UserService) AddUserToGuild(u *goff.User, g *goff.Guild) error {
-	queryString := `INSERT INTO x_users_guilds (user_id, guild_id) VALUES ($1, $2)`
+	queryString := `INSERT INTO x_users_guilds (user_id, guild_id) VALUES ($1, $2) ON CONFLICT DO NOTHING`
 	_, err := s.DB.Exec(queryString, u.ID, g.ID)
 	return err
 }

internal/services/services.go

@@ -4,8 +4,10 @@ import "github.com/dustinpianalto/goff"
 
 var UserService goff.UserService
 var GuildService goff.GuildService
+var RoleService goff.RoleService
 
-func InitalizeServices(us goff.UserService, gs goff.GuildService) {
+func InitalizeServices(us goff.UserService, gs goff.GuildService, rs goff.RoleService) {
 	UserService = us
 	GuildService = gs
+	RoleService = rs
 }

role.go

@@ -0,0 +1,21 @@
+package goff
+
+type Role struct {
+	ID             string
+	IsModerator    bool
+	IsAdmin        bool
+	SelfAssignable bool
+	AutoRole       bool
+	Guild          string
+}
+
+type RoleService interface {
+	Role(id string) (*Role, error)
+	AddRole(r *Role) (*Role, error)
+	DeleteRole(r *Role) error
+	MakeSelfAssignable(r *Role) error
+	RemoveSelfAssignable(r *Role) error
+	MakeAutoRole(r *Role) error
+	RemoveAutoRole(r *Role) error
+	GetAutoRoles(gID string) ([]*Role, error)
+}

task-definition.json

@@ -0,0 +1,134 @@
+{
+  "ipcMode": null,
+  "executionRoleArn": "arn:aws:iam::005692590034:role/goff_ecs_rds+cw+ecr",
+  "containerDefinitions": [
+    {
+      "dnsSearchDomains": null,
+      "environmentFiles": null,
+      "logConfiguration": {
+        "logDriver": "awslogs",
+        "secretOptions": null,
+        "options": {
+          "awslogs-group": "/ecs/goff",
+          "awslogs-region": "us-east-1",
+          "awslogs-stream-prefix": "ecs"
+        }
+      },
+      "entryPoint": null,
+      "portMappings": [],
+      "command": null,
+      "linuxParameters": null,
+      "cpu": 0,
+      "environment": [],
+      "resourceRequirements": null,
+      "ulimits": null,
+      "dnsServers": null,
+      "mountPoints": [],
+      "workingDirectory": null,
+      "secrets": [
+        {
+          "valueFrom": "goff_database_uri",
+          "name": "DATABASE_URL"
+        },
+        {
+          "valueFrom": "goff_discord_token",
+          "name": "DISCORDGO_TOKEN"
+        },
+        {
+          "valueFrom": "goff_email_password",
+          "name": "GOFF_EMAIL_PASSWORD"
+        },
+        {
+          "valueFrom": "goff_email_username",
+          "name": "GOFF_EMAIL_USERNAME"
+        }
+      ],
+      "dockerSecurityOptions": null,
+      "memory": 512,
+      "memoryReservation": null,
+      "volumesFrom": [],
+      "stopTimeout": null,
+      "image": "005692590034.dkr.ecr.us-east-1.amazonaws.com/goff:latest",
+      "startTimeout": null,
+      "firelensConfiguration": null,
+      "dependsOn": null,
+      "disableNetworking": null,
+      "interactive": null,
+      "healthCheck": null,
+      "essential": true,
+      "links": null,
+      "hostname": null,
+      "extraHosts": null,
+      "pseudoTerminal": null,
+      "user": null,
+      "readonlyRootFilesystem": null,
+      "dockerLabels": null,
+      "systemControls": null,
+      "privileged": null,
+      "name": "goff"
+    }
+  ],
+  "placementConstraints": [],
+  "memory": "512",
+  "taskRoleArn": "arn:aws:iam::005692590034:role/goff_ecs_rds+cw+ecr",
+  "compatibilities": [
+    "EC2"
+  ],
+  "taskDefinitionArn": "arn:aws:ecs:us-east-1:005692590034:task-definition/goff:2",
+  "family": "goff",
+  "requiresAttributes": [
+    {
+      "targetId": null,
+      "targetType": null,
+      "value": null,
+      "name": "com.amazonaws.ecs.capability.logging-driver.awslogs"
+    },
+    {
+      "targetId": null,
+      "targetType": null,
+      "value": null,
+      "name": "ecs.capability.execution-role-awslogs"
+    },
+    {
+      "targetId": null,
+      "targetType": null,
+      "value": null,
+      "name": "com.amazonaws.ecs.capability.ecr-auth"
+    },
+    {
+      "targetId": null,
+      "targetType": null,
+      "value": null,
+      "name": "com.amazonaws.ecs.capability.docker-remote-api.1.19"
+    },
+    {
+      "targetId": null,
+      "targetType": null,
+      "value": null,
+      "name": "com.amazonaws.ecs.capability.task-iam-role"
+    },
+    {
+      "targetId": null,
+      "targetType": null,
+      "value": null,
+      "name": "ecs.capability.execution-role-ecr-pull"
+    },
+    {
+      "targetId": null,
+      "targetType": null,
+      "value": null,
+      "name": "ecs.capability.secrets.ssm.environment-variables"
+    }
+  ],
+  "pidMode": null,
+  "requiresCompatibilities": [
+    "EC2"
+  ],
+  "networkMode": null,
+  "cpu": "1024",
+  "revision": 2,
+  "status": "ACTIVE",
+  "inferenceAccelerators": null,
+  "proxyConfiguration": null,
+  "volumes": []
+}

user.go

@@ -13,7 +13,7 @@ type User struct {
 
 type UserService interface {
 	User(id string) (*User, error)
-	CreateUser(u *User) error
+	CreateUser(u *User, gid string) error
 	DeleteUser(u *User) error
 	MarkUserInactive(u *User) error
 	AddUserToGuild(u *User, g *Guild) error