feat: implement purge subcommand

cmd/cli/cli.go

@@ -5,6 +5,8 @@ import (
 	"errors"
 	"os"
 
+	"github.com/bilalcaliskan/split-the-tunnel/cmd/cli/purge"
+
 	"github.com/bilalcaliskan/split-the-tunnel/internal/constants"
 	"github.com/bilalcaliskan/split-the-tunnel/internal/logging"
 
@@ -64,4 +66,5 @@ func init() {
 	cliCmd.AddCommand(add.AddCmd)
 	cliCmd.AddCommand(list.ListCmd)
 	cliCmd.AddCommand(remove.RemoveCmd)
+	cliCmd.AddCommand(purge.PurgeCmd)
 }

cmd/cli/purge/purge.go

@@ -0,0 +1,50 @@
+package purge
+
+import (
+	"github.com/rs/zerolog"
+
+	"github.com/bilalcaliskan/split-the-tunnel/internal/constants"
+
+	"github.com/bilalcaliskan/split-the-tunnel/cmd/cli/utils"
+	"github.com/spf13/cobra"
+)
+
+// PurgeCmd represents the purge command
+var PurgeCmd = &cobra.Command{
+	Use:   "purge",
+	Short: "A brief description of your command",
+	Long: `A longer description that spans multiple lines and likely contains examples
+and usage of using your command. For example:
+
+Cobra is a CLI library for Go that empowers applications.
+This application is a tool to generate the needed files
+to quickly create a Cobra application.`,
+	PreRunE: func(cmd *cobra.Command, args []string) error {
+		if len(args) > 0 {
+			return utils.ErrTooManyArgs
+		}
+
+		return nil
+	},
+	RunE: func(cmd *cobra.Command, args []string) error {
+		logger := cmd.Context().Value(constants.LoggerKey{}).(zerolog.Logger)
+
+		logger.Info().
+			Str("operation", cmd.Name()).
+			Msg(constants.ProcessCommand)
+
+		res, err := utils.SendCommandToDaemon(utils.SocketPath, cmd.Name())
+		if err != nil {
+			logger.Error().Str("command", cmd.Name()).Err(err).Msg(constants.FailedToProcessCommand)
+
+			return &utils.CommandError{Err: err, Code: 10}
+		}
+
+		logger.Info().
+			Str("command", cmd.Name()).
+			Str("response", res).
+			Msg(constants.SuccessfullyProcessed)
+
+		return nil
+	},
+}

internal/ipc/ipc.go

@@ -107,6 +107,10 @@ func processCommand(logger zerolog.Logger, command, gateway string, conn net.Con
 		logger = logger.With().Str("operation", "list").Logger()
 
 		handleListCommand(logger, conn, st)
+	case "purge":
+		logger = logger.With().Str("operation", "purge").Logger()
+
+		handlePurgeCommand(logger, conn, st)
 	}
 }
 
@@ -185,6 +189,49 @@ func handleAddCommand(logger zerolog.Logger, gw string, domains []string, conn n
 	}
 }
 
+func handlePurgeCommand(logger zerolog.Logger, conn net.Conn, st *state.State) {
+	logger = logger.With().Str("operation", "purge").Logger()
+
+	for _, entry := range st.Entries {
+		for _, ip := range entry.ResolvedIPs {
+			if err := utils.RemoveRoute(ip); err != nil {
+				logger.Error().Err(err).Str("domain", entry.Domain).Str("ip", ip).Msg("failed to remove route from routing table")
+
+				if err := writeResponse(&DaemonResponse{
+					Success:  false,
+					Response: "",
+					Error:    errors.Wrapf(err, "failed to remove route for domain %s from routing table", entry.Domain).Error(),
+				}, conn); err != nil {
+					logger.Error().
+						Err(err).
+						Str("domain", entry.Domain).
+						Msg(constants.FailedToWriteToUnixDomainSocket)
+				}
+
+				continue
+			}
+		}
+
+		logger.Info().Str("domain", entry.Domain).Msg("successfully removed route from routing table")
+	}
+
+	st.Entries = make([]*state.RouteEntry, 0)
+
+	if err := st.Write(constants.StateFilePath); err != nil {
+		logger.Error().Err(err).Msg("failed to write state to file")
+	}
+
+	if err := writeResponse(&DaemonResponse{
+		Success:  true,
+		Response: "purged all routes",
+		Error:    "",
+	}, conn); err != nil {
+		logger.Error().
+			Err(err).
+			Msg(constants.FailedToWriteToUnixDomainSocket)
+	}
+}
+
 // handleRemoveCommand removes the given domains from the routing table
 func handleRemoveCommand(logger zerolog.Logger, domains []string, conn net.Conn, st *state.State) {
 	logger = logger.With().Str("operation", "remove").Logger()