Refactoring-1811

ActivityPub/activity.go

@@ -5,18 +5,13 @@ import (
 	"crypto/rsa"
 	"crypto/sha256"
 	"encoding/base64"
-	"encoding/json"
 	"errors"
 	"fmt"
-	"io/ioutil"
 	"net/http"
-	"net/url"
 	"os"
 	"time"
 
 	"github.com/Songmu/go-httpdate"
-	"github.com/satori/go.uuid"
-	"github.com/yukimochi/Activity-Relay/KeyLoader"
 	"github.com/yukimochi/httpsig"
 )
 
@@ -60,112 +55,3 @@ func SendActivity(inboxURL string, KeyID string, refBytes []byte, pKey *rsa.Priv
 
 	return nil
 }
-
-// RetrieveActor : Retrieve Remote actor
-func RetrieveActor(url string) (*Actor, error) {
-	req, _ := http.NewRequest("GET", url, nil)
-	req.Header.Set("Accept", "application/activity+json, application/ld+json")
-	req.Header.Set("User-Agent", UA_STRING)
-	client := new(http.Client)
-	resp, err := client.Do(req)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	data, _ := ioutil.ReadAll(resp.Body)
-	var actor Actor
-	err = json.Unmarshal(data, &actor)
-	if err != nil {
-		return nil, err
-	}
-	return &actor, nil
-}
-
-// DescribeNestedActivity : Descrive Nested Activity Series
-func DescribeNestedActivity(nestedActivity interface{}) (*Activity, error) {
-	mappedObject := nestedActivity.(map[string]interface{})
-	if id, ok := mappedObject["id"].(string); ok {
-		if nestedType, ok := mappedObject["type"].(string); ok {
-			actor, ok := mappedObject["actor"].(string)
-			if !ok {
-				actor = ""
-			}
-			switch object := mappedObject["object"].(type) {
-			case string:
-				return &Activity{
-					ID:     id,
-					Type:   nestedType,
-					Actor:  actor,
-					Object: object,
-				}, nil
-			default:
-				return &Activity{
-					ID:     id,
-					Type:   nestedType,
-					Actor:  actor,
-					Object: mappedObject["object"],
-				}, nil
-			}
-		}
-		return nil, errors.New("Can't assart type")
-	}
-	return nil, errors.New("Can't assart id")
-}
-
-// GenerateActor : Generate Actor by hostname and publickey
-func GenerateActor(hostname *url.URL, publickey *rsa.PublicKey) Actor {
-	return Actor{
-		[]string{"https://www.w3.org/ns/activitystreams", "https://w3id.org/security/v1"},
-		hostname.String() + "/actor",
-		"Service",
-		"relay",
-		hostname.String() + "/inbox",
-		nil,
-		PublicKey{
-			hostname.String() + "/actor#main-key",
-			hostname.String() + "/actor",
-			keyloader.GeneratePublicKeyPEMString(publickey),
-		},
-	}
-}
-
-// GenerateWebfingerResource : Generate Webfinger Resource
-func GenerateWebfingerResource(hostname *url.URL, actor *Actor) WebfingerResource {
-	return WebfingerResource{
-		"acct:" + actor.PreferredUsername + "@" + hostname.Host,
-		[]WebfingerLink{
-			WebfingerLink{
-				"self",
-				"application/activity+json",
-				actor.ID,
-			},
-		},
-	}
-}
-
-// GenerateActivityResponse : Generate Responce Activity to Activity
-func GenerateActivityResponse(host *url.URL, to *url.URL, responseType string, activity Activity) Activity {
-	return Activity{
-		[]string{"https://www.w3.org/ns/activitystreams"},
-		host.String() + "/activities/" + uuid.NewV4().String(),
-		host.String() + "/actor",
-		responseType,
-		&activity,
-		nil,
-		nil,
-	}
-}
-
-// GenerateActivityAnnounce : Generate Announce Activity to Activity
-func GenerateActivityAnnounce(host *url.URL, to *url.URL, actiivtyID string) Activity {
-	return Activity{
-		[]string{"https://www.w3.org/ns/activitystreams"},
-		host.String() + "/activities/" + uuid.NewV4().String(),
-		host.String() + "/actor",
-		"Announce",
-		actiivtyID,
-		[]string{host.String() + "/actor/followers"},
-		nil,
-	}
-}

ActivityPub/models.go

@@ -1,5 +1,17 @@
 package activitypub
 
+import (
+	"crypto/rsa"
+	"encoding/json"
+	"errors"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+
+	"github.com/satori/go.uuid"
+	"github.com/yukimochi/Activity-Relay/KeyLoader"
+)
+
 // PublicKey : Activity Certificate.
 type PublicKey struct {
 	ID           string `json:"id"`
@@ -23,6 +35,38 @@ type Actor struct {
 	PublicKey         PublicKey   `json:"publicKey"`
 }
 
+func (a *Actor) GenerateSelfKey(hostname *url.URL, publickey *rsa.PublicKey) {
+	a.Context = []string{"https://www.w3.org/ns/activitystreams"}
+	a.ID = hostname.String() + "/actor"
+	a.Type = "Service"
+	a.PreferredUsername = "relay"
+	a.Inbox = hostname.String() + "/inbox"
+	a.PublicKey = PublicKey{
+		hostname.String() + "/actor#main-key",
+		hostname.String() + "/actor",
+		keyloader.GeneratePublicKeyPEMString(publickey),
+	}
+}
+
+func (a *Actor) RetrieveRemoteActor(url string) error {
+	req, _ := http.NewRequest("GET", url, nil)
+	req.Header.Set("Accept", "application/activity+json, application/ld+json")
+	req.Header.Set("User-Agent", UA_STRING)
+	client := new(http.Client)
+	resp, err := client.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	data, _ := ioutil.ReadAll(resp.Body)
+	err = json.Unmarshal(data, &a)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
 // Activity : ActivityPub Activity.
 type Activity struct {
 	Context interface{} `json:"@context"`
@@ -34,6 +78,60 @@ type Activity struct {
 	Cc      []string    `json:"cc"`
 }
 
+func (a *Activity) GenerateResponse(host *url.URL, responseType string) Activity {
+	return Activity{
+		[]string{"https://www.w3.org/ns/activitystreams"},
+		host.String() + "/activities/" + uuid.NewV4().String(),
+		host.String() + "/actor",
+		responseType,
+		&a,
+		nil,
+		nil,
+	}
+}
+
+func (a *Activity) GenerateAnnounce(host *url.URL) Activity {
+	return Activity{
+		[]string{"https://www.w3.org/ns/activitystreams"},
+		host.String() + "/activities/" + uuid.NewV4().String(),
+		host.String() + "/actor",
+		"Announce",
+		a.ID,
+		[]string{host.String() + "/actor/followers"},
+		nil,
+	}
+}
+
+func (a *Activity) NestedActivity() (*Activity, error) {
+	mappedObject := a.Object.(map[string]interface{})
+	if id, ok := mappedObject["id"].(string); ok {
+		if nestedType, ok := mappedObject["type"].(string); ok {
+			actor, ok := mappedObject["actor"].(string)
+			if !ok {
+				actor = ""
+			}
+			switch object := mappedObject["object"].(type) {
+			case string:
+				return &Activity{
+					ID:     id,
+					Type:   nestedType,
+					Actor:  actor,
+					Object: object,
+				}, nil
+			default:
+				return &Activity{
+					ID:     id,
+					Type:   nestedType,
+					Actor:  actor,
+					Object: mappedObject["object"],
+				}, nil
+			}
+		}
+		return nil, errors.New("Can't assart type")
+	}
+	return nil, errors.New("Can't assart id")
+}
+
 // Signature : ActivityPub Header Signature.
 type Signature struct {
 	Type           string `json:"type"`
@@ -42,15 +140,26 @@ type Signature struct {
 	SignatureValue string `json:"signatureValue"`
 }
 
-// WebfingerResource : Webfinger Resource.
-type WebfingerResource struct {
-	Subject string          `json:"subject"`
-	Links   []WebfingerLink `json:"links"`
-}
-
 // WebfingerLink : Webfinger Link Resource.
 type WebfingerLink struct {
 	Rel  string `json:"rel"`
 	Type string `json:"type"`
 	Href string `json:"href"`
 }
+
+// WebfingerResource : Webfinger Resource.
+type WebfingerResource struct {
+	Subject string          `json:"subject"`
+	Links   []WebfingerLink `json:"links"`
+}
+
+func (a *WebfingerResource) GenerateFromActor(hostname *url.URL, actor *Actor) {
+	a.Subject = "acct:" + actor.PreferredUsername + "@" + hostname.Host
+	a.Links = []WebfingerLink{
+		WebfingerLink{
+			"self",
+			"application/activity+json",
+			actor.ID,
+		},
+	}
+}

Gopkg.lock

@@ -191,6 +191,14 @@
   pruneopts = "UT"
   revision = "0b12d6b5"
 
+[[projects]]
+  branch = "master"
+  digest = "1:1f251f2f217a800ef952995dac5fbe0615f4cacd0dc448a0dffd9176a09a3823"
+  name = "github.com/kami-zh/go-capturer"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "e492ea43421da7381e5200a2e22753bfc31347c2"
+
 [[projects]]
   digest = "1:edbef42561faa44c19129b68d1e109fbc1647f63239250391eadc8d0e7c9f669"
   name = "github.com/kelseyhightower/envconfig"
@@ -476,6 +484,7 @@
     "github.com/RichardKnop/machinery/v1/tasks",
     "github.com/Songmu/go-httpdate",
     "github.com/go-redis/redis",
+    "github.com/kami-zh/go-capturer",
     "github.com/satori/go.uuid",
     "github.com/urfave/cli",
     "github.com/yukimochi/httpsig",

KeyLoader/keyloader.go

@@ -6,7 +6,6 @@ import (
 	"encoding/pem"
 	"fmt"
 	"io/ioutil"
-	"unsafe"
 )
 
 func ReadPrivateKeyRSAfromPath(path string) (*rsa.PrivateKey, error) {
@@ -23,7 +22,7 @@ func ReadPrivateKeyRSAfromPath(path string) (*rsa.PrivateKey, error) {
 }
 
 func ReadPublicKeyRSAfromString(pemString string) (*rsa.PublicKey, error) {
-	pemByte := *(*[]byte)(unsafe.Pointer(&pemString))
+	pemByte := []byte(pemString)
 	decoded, _ := pem.Decode(pemByte)
 	keyInterface, err := x509.ParsePKIXPublicKey(decoded.Bytes)
 	if err != nil {

RelayConf/relayconf.go

@@ -9,34 +9,49 @@ type RelayConfig struct {
 	CreateAsAnnounce bool
 }
 
-// LoadConfig : Loader for relay configuration
+type Config int
-func LoadConfig(redClient *redis.Client) RelayConfig {
+
-	blockService, err := redClient.HGet("relay:config", "block_service").Result()
+const (
+	BlockService Config = iota
+	ManuallyAccept
+	CreateAsAnnounce
+)
+
+func (c *RelayConfig) Load(r *redis.Client) {
+	blockService, err := r.HGet("relay:config", "block_service").Result()
 	if err != nil {
-		redClient.HSet("relay:config", "block_service", 0)
+		c.Set(r, BlockService, false)
 		blockService = "0"
 	}
-	manuallyAccept, err := redClient.HGet("relay:config", "manually_accept").Result()
+	manuallyAccept, err := r.HGet("relay:config", "manually_accept").Result()
 	if err != nil {
-		redClient.HSet("relay:config", "manually_accept", 0)
+		c.Set(r, ManuallyAccept, false)
 		manuallyAccept = "0"
 	}
-	createAsAnnounce, err := redClient.HGet("relay:config", "create_as_announce").Result()
+	createAsAnnounce, err := r.HGet("relay:config", "create_as_announce").Result()
 	if err != nil {
-		redClient.HSet("relay:config", "create_as_announce", 0)
+		c.Set(r, CreateAsAnnounce, false)
 		createAsAnnounce = "0"
 	}
-	return RelayConfig{
+	c.BlockService = blockService == "1"
-		BlockService:     blockService == "1",
+	c.ManuallyAccept = manuallyAccept == "1"
-		ManuallyAccept:   manuallyAccept == "1",
+	c.CreateAsAnnounce = createAsAnnounce == "1"
-		CreateAsAnnounce: createAsAnnounce == "1",
-	}
 }
 
-func SetConfig(redClient *redis.Client, key string, value bool) {
+func (c *RelayConfig) Set(r *redis.Client, key Config, value bool) {
 	strValue := 0
 	if value {
 		strValue = 1
 	}
-	redClient.HSet("relay:config", key, strValue)
+	switch key {
+	case BlockService:
+		c.BlockService = value
+		r.HSet("relay:config", "block_service", strValue)
+	case ManuallyAccept:
+		c.ManuallyAccept = value
+		r.HSet("relay:config", "manually_accept", strValue)
+	case CreateAsAnnounce:
+		c.CreateAsAnnounce = value
+		r.HSet("relay:config", "create_as_announce", strValue)
+	}
 }

cli/cli.go

@@ -12,12 +12,14 @@ import (
 	"github.com/go-redis/redis"
 	"github.com/urfave/cli"
 	"github.com/yukimochi/Activity-Relay/KeyLoader"
+	"github.com/yukimochi/Activity-Relay/RelayConf"
 )
 
 var hostname *url.URL
 var hostkey *rsa.PrivateKey
 var redClient *redis.Client
 var macServer *machinery.Server
+var relConfig relayconf.RelayConfig
 
 func main() {
 	pemPath := os.Getenv("ACTOR_PEM")

cli/cli_test.go

@@ -0,0 +1,36 @@
+package main
+
+import (
+	"net/url"
+	"os"
+	"testing"
+
+	"github.com/RichardKnop/machinery/v1"
+	"github.com/RichardKnop/machinery/v1/config"
+	"github.com/go-redis/redis"
+	"github.com/yukimochi/Activity-Relay/KeyLoader"
+)
+
+func TestMain(m *testing.M) {
+	os.Setenv("ACTOR_PEM", "misc/testKey.pem")
+	os.Setenv("RELAY_DOMAIN", "relay.yukimochi.example.org")
+	pemPath := os.Getenv("ACTOR_PEM")
+	relayDomain := os.Getenv("RELAY_DOMAIN")
+	redisURL := os.Getenv("REDIS_URL")
+	hostkey, _ = keyloader.ReadPrivateKeyRSAfromPath(pemPath)
+	hostname, _ = url.Parse("https://" + relayDomain)
+	redClient = redis.NewClient(&redis.Options{
+		Addr: redisURL,
+	})
+	var macConfig = &config.Config{
+		Broker:          "redis://" + redisURL,
+		DefaultQueue:    "relay",
+		ResultBackend:   "redis://" + redisURL,
+		ResultsExpireIn: 5,
+	}
+	macServer, _ = machinery.NewServer(macConfig)
+	redClient.FlushAll().Result()
+	relConfig.Load(redClient)
+	code := m.Run()
+	os.Exit(code)
+}

cli/config.go

@@ -7,40 +7,46 @@ import (
 	"github.com/yukimochi/Activity-Relay/RelayConf"
 )
 
+const (
+	BlockService relayconf.Config = iota
+	ManuallyAccept
+	CreateAsAnnounce
+)
+
 func serviceBlock(c *cli.Context) {
 	if c.Bool("undo") {
-		relayconf.SetConfig(redClient, "block_service", false)
+		relConfig.Set(redClient, BlockService, false)
 		fmt.Println("Blocking for service-type actor is Disabled.")
 	} else {
-		relayconf.SetConfig(redClient, "block_service", true)
+		relConfig.Set(redClient, BlockService, true)
 		fmt.Println("Blocking for service-type actor is Enabled.")
 	}
 }
 
 func manuallyAccept(c *cli.Context) {
 	if c.Bool("undo") {
-		relayconf.SetConfig(redClient, "manually_accept", false)
+		relConfig.Set(redClient, ManuallyAccept, false)
 		fmt.Println("Manually accept follow-request is Disabled.")
 	} else {
-		relayconf.SetConfig(redClient, "manually_accept", true)
+		relConfig.Set(redClient, ManuallyAccept, true)
 		fmt.Println("Manually accept follow-request is Enabled.")
 	}
 }
 
 func createAsAnnounce(c *cli.Context) {
 	if c.Bool("undo") {
-		relayconf.SetConfig(redClient, "create_as_announce", false)
+		relConfig.Set(redClient, CreateAsAnnounce, false)
 		fmt.Println("Announce activity instead of relay create activity is Disabled.")
 	} else {
-		relayconf.SetConfig(redClient, "create_as_announce", true)
+		relConfig.Set(redClient, CreateAsAnnounce, true)
 		fmt.Println("Announce activity instead of relay create activity is Enabled.")
 	}
 }
 
 func listConfigs(c *cli.Context) {
-	config := relayconf.LoadConfig(redClient)
+	relConfig.Load(redClient)
 
-	fmt.Println("Blocking for service-type actor : ", config.BlockService)
+	fmt.Println("Blocking for service-type actor : ", relConfig.BlockService)
-	fmt.Println("Manually accept follow-request : ", config.ManuallyAccept)
+	fmt.Println("Manually accept follow-request : ", relConfig.ManuallyAccept)
-	fmt.Println("Announce activity instead of relay create activity : ", config.CreateAsAnnounce)
+	fmt.Println("Announce activity instead of relay create activity : ", relConfig.CreateAsAnnounce)
 }

cli/config_test.go

@@ -0,0 +1,156 @@
+package main
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/kami-zh/go-capturer"
+	"github.com/urfave/cli"
+)
+
+func TestServiceBlock(t *testing.T) {
+	app := cli.NewApp()
+	fooCmd := cli.Command{
+		Name:  "service-block",
+		Usage: "Enable blocking for service-type actor",
+		Flags: []cli.Flag{
+			cli.BoolFlag{
+				Name:  "undo, u",
+				Usage: "Undo block",
+			},
+		},
+		Action: serviceBlock,
+	}
+	app.Commands = []cli.Command{
+		fooCmd,
+	}
+
+	relConfig.Set(redClient, BlockService, false)
+	app.Run([]string{"", "service-block"})
+	if !relConfig.BlockService {
+		t.Fatalf("Not Enabled ServiceBlock feature,")
+	}
+
+	app.Run([]string{"", "service-block", "-u"})
+	if relConfig.BlockService {
+		t.Fatalf("Not Disabled ServiceBlock feature,")
+	}
+}
+
+func TestManuallyAccept(t *testing.T) {
+	app := cli.NewApp()
+	fooCmd := cli.Command{
+		Name:  "manually-accept",
+		Usage: "Enable Manually accept follow-request",
+		Flags: []cli.Flag{
+			cli.BoolFlag{
+				Name:  "undo, u",
+				Usage: "Undo block",
+			},
+		},
+		Action: manuallyAccept,
+	}
+	app.Commands = []cli.Command{
+		fooCmd,
+	}
+
+	relConfig.Set(redClient, ManuallyAccept, false)
+	app.Run([]string{"", "manually-accept"})
+	if !relConfig.ManuallyAccept {
+		t.Fatalf("Not Enabled Manually accept follow-request feature,")
+	}
+
+	app.Run([]string{"", "manually-accept", "-u"})
+	if relConfig.ManuallyAccept {
+		t.Fatalf("Not Disabled Manually accept follow-request feature,")
+	}
+}
+
+func TestCreateAsAnnounce(t *testing.T) {
+	app := cli.NewApp()
+	fooCmd := cli.Command{
+		Name:  "create-as-announce",
+		Usage: "Enable Announce activity instead of relay create activity (Not recommended)",
+		Flags: []cli.Flag{
+			cli.BoolFlag{
+				Name:  "undo, u",
+				Usage: "Undo block",
+			},
+		},
+		Action: createAsAnnounce,
+	}
+	app.Commands = []cli.Command{
+		fooCmd,
+	}
+
+	relConfig.Set(redClient, CreateAsAnnounce, false)
+	app.Run([]string{"", "create-as-announce"})
+	if !relConfig.CreateAsAnnounce {
+		t.Fatalf("Not Enabled Announce activity instead of relay create activity feature,")
+	}
+
+	app.Run([]string{"", "create-as-announce", "-u"})
+	if relConfig.CreateAsAnnounce {
+		t.Fatalf("Not Disabled Announce activity instead of relay create activity feature,")
+	}
+}
+
+func TestListConfigs(t *testing.T) {
+	app := cli.NewApp()
+	fooCmd := cli.Command{
+		Name:   "show",
+		Usage:  "Show all relay configrations",
+		Action: listConfigs,
+	}
+	app.Commands = []cli.Command{
+		fooCmd,
+	}
+
+	relConfig.Set(redClient, BlockService, true)
+	relConfig.Set(redClient, ManuallyAccept, true)
+	relConfig.Set(redClient, CreateAsAnnounce, true)
+	out := capturer.CaptureStdout(func() {
+		app.Run([]string{"", "show"})
+	})
+
+	for _, row := range strings.Split(out, "\n") {
+		switch strings.Split(row, ":")[0] {
+		case "Blocking for service-type actor ":
+			if !(strings.Split(row, ":")[1] == "  true") {
+				t.Fatalf(strings.Split(row, ":")[1])
+			}
+		case "Manually accept follow-request ":
+			if !(strings.Split(row, ":")[1] == "  true") {
+				t.Fatalf("Invalid Responce.")
+			}
+		case "Announce activity instead of relay create activity ":
+			if !(strings.Split(row, ":")[1] == "  true") {
+				t.Fatalf("Invalid Responce.")
+			}
+		}
+	}
+
+	relConfig.Set(redClient, BlockService, false)
+	relConfig.Set(redClient, ManuallyAccept, false)
+	relConfig.Set(redClient, CreateAsAnnounce, false)
+	out = capturer.CaptureStdout(func() {
+		app.Run([]string{"", "show"})
+	})
+
+	for _, row := range strings.Split(out, "\n") {
+		switch strings.Split(row, ":")[0] {
+		case "Blocking for service-type actor ":
+			if !(strings.Split(row, ":")[1] == "  false") {
+				t.Fatalf("Invalid Responce.")
+			}
+		case "Manually accept follow-request ":
+			if !(strings.Split(row, ":")[1] == "  false") {
+				t.Fatalf("Invalid Responce.")
+			}
+		case "Announce activity instead of relay create activity ":
+			if !(strings.Split(row, ":")[1] == "  false") {
+				t.Fatalf("Invalid Responce.")
+			}
+		}
+	}
+}

cli/follow.go

@@ -3,9 +3,7 @@ package main
 import (
 	"encoding/json"
 	"fmt"
-	"net/url"
 	"strings"
-	"unsafe"
 
 	"github.com/RichardKnop/machinery/v1/tasks"
 	"github.com/urfave/cli"
@@ -25,7 +23,7 @@ func pushRegistorJob(inboxURL string, body []byte) {
 			{
 				Name:  "body",
 				Type:  "string",
-				Value: *(*string)(unsafe.Pointer(&body)),
+				Value: string(body),
 			},
 		},
 	}
@@ -80,8 +78,7 @@ func acceptFollow(c *cli.Context) error {
 			nil,
 		}
 
-		actorDomain, _ := url.Parse(activity.Actor)
+		resp := activity.GenerateResponse(hostname, "Accept")
-		resp := activitypub.GenerateActivityResponse(hostname, actorDomain, "Accept", activity)
 		jsonData, _ := json.Marshal(&resp)
 
 		pushRegistorJob(data["inbox_url"], jsonData)
@@ -121,8 +118,7 @@ func rejectFollow(c *cli.Context) error {
 			nil,
 		}
 
-		actorDomain, _ := url.Parse(activity.Actor)
+		resp := activity.GenerateResponse(hostname, "Reject")
-		resp := activitypub.GenerateActivityResponse(hostname, actorDomain, "Reject", activity)
 		jsonData, _ := json.Marshal(&resp)
 
 		pushRegistorJob(data["inbox_url"], jsonData)

decode.go

@@ -25,7 +25,8 @@ func decodeActivity(r *http.Request) (*activitypub.Activity, *activitypub.Actor,
 		return nil, nil, nil, err
 	}
 	KeyID := verifier.KeyId()
-	remoteActor, err := activitypub.RetrieveActor(KeyID)
+	remoteActor := new(activitypub.Actor)
+	err = remoteActor.RetrieveRemoteActor(KeyID)
 	if err != nil {
 		return nil, nil, nil, err
 	}

handle.go

@@ -7,7 +7,6 @@ import (
 	"net/http"
 	"net/url"
 	"strings"
-	"unsafe"
 
 	"github.com/RichardKnop/machinery/v1/tasks"
 	"github.com/yukimochi/Activity-Relay/ActivityPub"
@@ -82,7 +81,7 @@ func pushRelayJob(sourceInbox string, body []byte) {
 					{
 						Name:  "body",
 						Type:  "string",
-						Value: *(*string)(unsafe.Pointer(&body)),
+						Value: string(body),
 					},
 				},
 			}
@@ -107,7 +106,7 @@ func pushRegistorJob(inboxURL string, body []byte) {
 			{
 				Name:  "body",
 				Type:  "string",
-				Value: *(*string)(unsafe.Pointer(&body)),
+				Value: string(body),
 			},
 		},
 	}
@@ -179,7 +178,7 @@ func handleInbox(w http.ResponseWriter, r *http.Request, activityDecoder func(*h
 			case "Follow":
 				err = followAcceptable(activity, actor)
 				if err != nil {
-					resp := activitypub.GenerateActivityResponse(hostname, domain, "Reject", *activity)
+					resp := activity.GenerateResponse(hostname, "Reject")
 					jsonData, _ := json.Marshal(&resp)
 					go pushRegistorJob(actor.Inbox, jsonData)
 					fmt.Println("Reject Follow Request : ", err.Error(), activity.Actor)
@@ -198,14 +197,14 @@ func handleInbox(w http.ResponseWriter, r *http.Request, activityDecoder func(*h
 							})
 							fmt.Println("Pending Follow Request : ", activity.Actor)
 						} else {
-							resp := activitypub.GenerateActivityResponse(hostname, domain, "Accept", *activity)
+							resp := activity.GenerateResponse(hostname, "Accept")
 							jsonData, _ := json.Marshal(&resp)
 							go pushRegistorJob(actor.Inbox, jsonData)
 							redClient.HSet("relay:subscription:"+domain.Host, "inbox_url", actor.Endpoints.SharedInbox)
 							fmt.Println("Accept Follow Request : ", activity.Actor)
 						}
 					} else {
-						resp := activitypub.GenerateActivityResponse(hostname, domain, "Reject", *activity)
+						resp := activity.GenerateResponse(hostname, "Reject")
 						jsonData, _ := json.Marshal(&resp)
 						go pushRegistorJob(actor.Inbox, jsonData)
 						fmt.Println("Reject Follow Request : ", activity.Actor)
@@ -215,7 +214,7 @@ func handleInbox(w http.ResponseWriter, r *http.Request, activityDecoder func(*h
 					w.Write(nil)
 				}
 			case "Undo":
-				nestedActivity, _ := activitypub.DescribeNestedActivity(activity.Object)
+				nestedActivity, _ := activity.NestedActivity()
 				if nestedActivity.Type == "Follow" && nestedActivity.Actor == activity.Actor {
 					err = unFollowAcceptable(nestedActivity, actor)
 					if err != nil {
@@ -251,13 +250,13 @@ func handleInbox(w http.ResponseWriter, r *http.Request, activityDecoder func(*h
 				} else {
 					if suitableRelay(activity, actor) {
 						if relConfig.CreateAsAnnounce && activity.Type == "Create" {
-							nestedObject, err := activitypub.DescribeNestedActivity(activity.Object)
+							nestedObject, err := activity.NestedActivity()
 							if err != nil {
 								fmt.Println("Fail Assert activity : activity.Actor")
 							}
 							switch nestedObject.Type {
 							case "Note":
-								resp := activitypub.GenerateActivityAnnounce(hostname, domain, nestedObject.ID)
+								resp := nestedObject.GenerateAnnounce(hostname)
 								jsonData, _ := json.Marshal(&resp)
 								go pushRelayJob(domain.Host, jsonData)
 								fmt.Println("Accept Announce Note : ", activity.Actor)

handle_test.go

@@ -14,6 +14,12 @@ import (
 	"github.com/yukimochi/Activity-Relay/RelayConf"
 )
 
+const (
+	BlockService relayconf.Config = iota
+	ManuallyAccept
+	CreateAsAnnounce
+)
+
 func TestHandleWebfingerGet(t *testing.T) {
 	s := httptest.NewServer(http.HandlerFunc(handleWebfinger))
 	defer s.Close()
@@ -259,8 +265,7 @@ func TestSuitableRelayNoBlockService(t *testing.T) {
 	personActor := mockActor("Person")
 	serviceActor := mockActor("Service")
 
-	relayconf.SetConfig(redClient, "block_service", false)
+	relConfig.Set(redClient, BlockService, false)
-	relConfig = relayconf.LoadConfig(redClient)
 
 	if suitableRelay(&activity, &personActor) != true {
 		t.Fatalf("Failed - Person status not relay")
@@ -275,8 +280,7 @@ func TestSuitableRelayBlockService(t *testing.T) {
 	personActor := mockActor("Person")
 	serviceActor := mockActor("Service")
 
-	relayconf.SetConfig(redClient, "block_service", true)
+	relConfig.Set(redClient, BlockService, true)
-	relConfig = relayconf.LoadConfig(redClient)
 
 	if suitableRelay(&activity, &personActor) != true {
 		t.Fatalf("Failed - Person status not relay")
@@ -284,8 +288,7 @@ func TestSuitableRelayBlockService(t *testing.T) {
 	if suitableRelay(&activity, &serviceActor) != false {
 		t.Fatalf("Failed - Service status may relay when blocking mode")
 	}
-	relayconf.SetConfig(redClient, "block_service", false)
+	relConfig.Set(redClient, BlockService, false)
-	relConfig = relayconf.LoadConfig(redClient)
 }
 
 func TestHandleInboxNoSignature(t *testing.T) {
@@ -331,8 +334,7 @@ func TestHandleInboxValidFollow(t *testing.T) {
 	}))
 	defer s.Close()
 
-	relayconf.SetConfig(redClient, "manually_accept", false)
+	relConfig.Set(redClient, ManuallyAccept, false)
-	relConfig = relayconf.LoadConfig(redClient)
 
 	req, _ := http.NewRequest("POST", s.URL, nil)
 	client := new(http.Client)
@@ -361,8 +363,7 @@ func TestHandleInboxValidManuallyFollow(t *testing.T) {
 	defer s.Close()
 
 	// Switch Manually
-	relayconf.SetConfig(redClient, "manually_accept", true)
+	relConfig.Set(redClient, ManuallyAccept, true)
-	relConfig = relayconf.LoadConfig(redClient)
 
 	req, _ := http.NewRequest("POST", s.URL, nil)
 	client := new(http.Client)
@@ -383,8 +384,7 @@ func TestHandleInboxValidManuallyFollow(t *testing.T) {
 	}
 	redClient.Del("relay:subscription:" + domain.Host).Result()
 	redClient.Del("relay:pending:" + domain.Host).Result()
-	relayconf.SetConfig(redClient, "manually_accept", false)
+	relConfig.Set(redClient, ManuallyAccept, false)
-	relConfig = relayconf.LoadConfig(redClient)
 }
 
 func TestHandleInboxInvalidFollow(t *testing.T) {
@@ -396,8 +396,7 @@ func TestHandleInboxInvalidFollow(t *testing.T) {
 	}))
 	defer s.Close()
 
-	relayconf.SetConfig(redClient, "manually_accept", false)
+	relConfig.Set(redClient, ManuallyAccept, false)
-	relConfig = relayconf.LoadConfig(redClient)
 
 	req, _ := http.NewRequest("POST", s.URL, nil)
 	client := new(http.Client)
@@ -585,8 +584,7 @@ func TestHandleInboxValidCreateAsAnnounceNote(t *testing.T) {
 
 	redClient.HSet("relay:subscription:"+domain.Host, "inbox_url", "https://mastodon.test.yukimochi.io/inbox").Result()
 	redClient.HSet("relay:subscription:example.org", "inbox_url", "https://example.org/inbox").Result()
-	redClient.HSet("relay:config", "create_as_announce", "1").Result()
+	relConfig.Set(redClient, CreateAsAnnounce, true)
-	relConfig = relayconf.LoadConfig(redClient)
 
 	req, _ := http.NewRequest("POST", s.URL, nil)
 	client := new(http.Client)
@@ -599,8 +597,7 @@ func TestHandleInboxValidCreateAsAnnounceNote(t *testing.T) {
 	}
 	redClient.Del("relay:subscription:" + domain.Host).Result()
 	redClient.Del("relay:subscription:example.org").Result()
-	redClient.HSet("relay:config", "create_as_announce", "0").Result()
+	relConfig.Set(redClient, CreateAsAnnounce, false)
-	relConfig = relayconf.LoadConfig(redClient)
 }
 
 func TestHandleInboxValidCreateAsAnnounceNoNote(t *testing.T) {
@@ -614,8 +611,7 @@ func TestHandleInboxValidCreateAsAnnounceNoNote(t *testing.T) {
 
 	redClient.HSet("relay:subscription:"+domain.Host, "inbox_url", "https://mastodon.test.yukimochi.io/inbox").Result()
 	redClient.HSet("relay:subscription:example.org", "inbox_url", "https://example.org/inbox").Result()
-	redClient.HSet("relay:config", "create_as_announce", "1").Result()
+	relConfig.Set(redClient, CreateAsAnnounce, true)
-	relConfig = relayconf.LoadConfig(redClient)
 
 	req, _ := http.NewRequest("POST", s.URL, nil)
 	client := new(http.Client)
@@ -628,8 +624,7 @@ func TestHandleInboxValidCreateAsAnnounceNoNote(t *testing.T) {
 	}
 	redClient.Del("relay:subscription:" + domain.Host).Result()
 	redClient.Del("relay:subscription:example.org").Result()
-	redClient.HSet("relay:config", "create_as_announce", "0").Result()
+	relConfig.Set(redClient, CreateAsAnnounce, false)
-	relConfig = relayconf.LoadConfig(redClient)
 }
 
 func TestHandleInboxUnsubscriptionCreate(t *testing.T) {

main.go

@@ -70,11 +70,11 @@ func main() {
 		fmt.Println(err)
 	}
 
-	Actor = activitypub.GenerateActor(hostname, &hostkey.PublicKey)
+	Actor.GenerateSelfKey(hostname, &hostkey.PublicKey)
-	WebfingerResource = activitypub.GenerateWebfingerResource(hostname, &Actor)
+	WebfingerResource.GenerateFromActor(hostname, &Actor)
 
 	// Load Config
-	relConfig = relayconf.LoadConfig(redClient)
+	relConfig.Load(redClient)
 
 	http.HandleFunc("/.well-known/webfinger", handleWebfinger)
 	http.HandleFunc("/actor", handleActor)

main_test.go

@@ -5,12 +5,10 @@ import (
 	"os"
 	"testing"
 
-	machinery "github.com/RichardKnop/machinery/v1"
+	"github.com/RichardKnop/machinery/v1"
 	"github.com/RichardKnop/machinery/v1/config"
 	"github.com/go-redis/redis"
-	activitypub "github.com/yukimochi/Activity-Relay/ActivityPub"
+	"github.com/yukimochi/Activity-Relay/KeyLoader"
-	keyloader "github.com/yukimochi/Activity-Relay/KeyLoader"
-	relayconf "github.com/yukimochi/Activity-Relay/RelayConf"
 )
 
 func TestMain(m *testing.M) {
@@ -32,11 +30,11 @@ func TestMain(m *testing.M) {
 	}
 	macServer, _ = machinery.NewServer(macConfig)
 
-	Actor = activitypub.GenerateActor(hostname, &hostkey.PublicKey)
+	Actor.GenerateSelfKey(hostname, &hostkey.PublicKey)
-	WebfingerResource = activitypub.GenerateWebfingerResource(hostname, &Actor)
+	WebfingerResource.GenerateFromActor(hostname, &Actor)
 
 	redClient.FlushAll().Result()
-	relConfig = relayconf.LoadConfig(redClient)
+	relConfig.Load(redClient)
 	code := m.Run()
 	os.Exit(code)
 }

worker/worker.go

@@ -6,7 +6,6 @@ import (
 	"net/url"
 	"os"
 	"time"
-	"unsafe"
 
 	"github.com/RichardKnop/machinery/v1"
 	"github.com/RichardKnop/machinery/v1/config"
@@ -30,7 +29,7 @@ var redClient *redis.Client
 func relayActivity(args ...string) error {
 	inboxURL := args[0]
 	body := args[1]
-	err := activitypub.SendActivity(inboxURL, Actor.ID, *(*[]byte)(unsafe.Pointer(&body)), Hostkey)
+	err := activitypub.SendActivity(inboxURL, Actor.ID, []byte(body), Hostkey)
 	if err != nil {
 		domain, _ := url.Parse(inboxURL)
 		mod, _ := redClient.HSetNX("relay:statistics:"+domain.Host, "last_error", err.Error()).Result()
@@ -44,7 +43,7 @@ func relayActivity(args ...string) error {
 func registorActivity(args ...string) error {
 	inboxURL := args[0]
 	body := args[1]
-	err := activitypub.SendActivity(inboxURL, Actor.ID, *(*[]byte)(unsafe.Pointer(&body)), Hostkey)
+	err := activitypub.SendActivity(inboxURL, Actor.ID, []byte(body), Hostkey)
 	return err
 }
 
@@ -74,7 +73,7 @@ func main() {
 	redClient = redis.NewClient(&redis.Options{
 		Addr: redisURL,
 	})
-	Actor = activitypub.GenerateActor(Hostname, &Hostkey.PublicKey)
+	Actor.GenerateSelfKey(Hostname, &Hostkey.PublicKey)
 
 	var macConfig = &config.Config{
 		Broker:          "redis://" + redisURL,