diff --git a/ActivityPub/activity.go b/ActivityPub/activity.go index 9a9a9ca..20071e5 100644 --- a/ActivityPub/activity.go +++ b/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, - } -} diff --git a/ActivityPub/models.go b/ActivityPub/models.go index 6913348..dcb4eab 100644 --- a/ActivityPub/models.go +++ b/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, + }, + } +} diff --git a/Gopkg.lock b/Gopkg.lock index feb976b..7184e4e 100644 --- a/Gopkg.lock +++ b/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", diff --git a/KeyLoader/keyloader.go b/KeyLoader/keyloader.go index 6231d4c..3ba58f2 100644 --- a/KeyLoader/keyloader.go +++ b/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 { diff --git a/RelayConf/relayconf.go b/RelayConf/relayconf.go index bb6c9e1..a963c2b 100644 --- a/RelayConf/relayconf.go +++ b/RelayConf/relayconf.go @@ -9,34 +9,49 @@ type RelayConfig struct { CreateAsAnnounce bool } -// LoadConfig : Loader for relay configuration -func LoadConfig(redClient *redis.Client) RelayConfig { - blockService, err := redClient.HGet("relay:config", "block_service").Result() +type Config int + +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{ - BlockService: blockService == "1", - ManuallyAccept: manuallyAccept == "1", - CreateAsAnnounce: createAsAnnounce == "1", - } + c.BlockService = blockService == "1" + c.ManuallyAccept = manuallyAccept == "1" + c.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) + } } diff --git a/cli/cli.go b/cli/cli.go index ddd4312..2799544 100644 --- a/cli/cli.go +++ b/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") diff --git a/cli/cli_test.go b/cli/cli_test.go new file mode 100644 index 0000000..55a1ec1 --- /dev/null +++ b/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) +} diff --git a/cli/config.go b/cli/config.go index 63e0d28..11e0209 100644 --- a/cli/config.go +++ b/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("Manually accept follow-request : ", config.ManuallyAccept) - fmt.Println("Announce activity instead of relay create activity : ", config.CreateAsAnnounce) + fmt.Println("Blocking for service-type actor : ", relConfig.BlockService) + fmt.Println("Manually accept follow-request : ", relConfig.ManuallyAccept) + fmt.Println("Announce activity instead of relay create activity : ", relConfig.CreateAsAnnounce) } diff --git a/cli/config_test.go b/cli/config_test.go new file mode 100644 index 0000000..76795a8 --- /dev/null +++ b/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.") + } + } + } +} diff --git a/cli/follow.go b/cli/follow.go index 5b57d23..80e48e7 100644 --- a/cli/follow.go +++ b/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 := activitypub.GenerateActivityResponse(hostname, actorDomain, "Accept", activity) + resp := activity.GenerateResponse(hostname, "Accept") 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 := activitypub.GenerateActivityResponse(hostname, actorDomain, "Reject", activity) + resp := activity.GenerateResponse(hostname, "Reject") jsonData, _ := json.Marshal(&resp) pushRegistorJob(data["inbox_url"], jsonData) diff --git a/decode.go b/decode.go index 9083227..c4dcc96 100644 --- a/decode.go +++ b/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 } diff --git a/handle.go b/handle.go index 35c6ab2..c6526f6 100644 --- a/handle.go +++ b/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) diff --git a/handle_test.go b/handle_test.go index a5eabca..c605088 100644 --- a/handle_test.go +++ b/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 = relayconf.LoadConfig(redClient) + relConfig.Set(redClient, BlockService, false) 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 = relayconf.LoadConfig(redClient) + relConfig.Set(redClient, BlockService, true) 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 = relayconf.LoadConfig(redClient) + relConfig.Set(redClient, BlockService, false) } func TestHandleInboxNoSignature(t *testing.T) { @@ -331,8 +334,7 @@ func TestHandleInboxValidFollow(t *testing.T) { })) defer s.Close() - relayconf.SetConfig(redClient, "manually_accept", false) - relConfig = relayconf.LoadConfig(redClient) + relConfig.Set(redClient, ManuallyAccept, false) 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 = relayconf.LoadConfig(redClient) + relConfig.Set(redClient, ManuallyAccept, true) 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 = relayconf.LoadConfig(redClient) + relConfig.Set(redClient, ManuallyAccept, false) } func TestHandleInboxInvalidFollow(t *testing.T) { @@ -396,8 +396,7 @@ func TestHandleInboxInvalidFollow(t *testing.T) { })) defer s.Close() - relayconf.SetConfig(redClient, "manually_accept", false) - relConfig = relayconf.LoadConfig(redClient) + relConfig.Set(redClient, ManuallyAccept, false) 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 = relayconf.LoadConfig(redClient) + relConfig.Set(redClient, CreateAsAnnounce, true) 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 = relayconf.LoadConfig(redClient) + relConfig.Set(redClient, CreateAsAnnounce, false) } 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 = relayconf.LoadConfig(redClient) + relConfig.Set(redClient, CreateAsAnnounce, true) 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 = relayconf.LoadConfig(redClient) + relConfig.Set(redClient, CreateAsAnnounce, false) } func TestHandleInboxUnsubscriptionCreate(t *testing.T) { diff --git a/main.go b/main.go index 49fa837..61ac4c4 100644 --- a/main.go +++ b/main.go @@ -70,11 +70,11 @@ func main() { fmt.Println(err) } - Actor = activitypub.GenerateActor(hostname, &hostkey.PublicKey) - WebfingerResource = activitypub.GenerateWebfingerResource(hostname, &Actor) + Actor.GenerateSelfKey(hostname, &hostkey.PublicKey) + WebfingerResource.GenerateFromActor(hostname, &Actor) // Load Config - relConfig = relayconf.LoadConfig(redClient) + relConfig.Load(redClient) http.HandleFunc("/.well-known/webfinger", handleWebfinger) http.HandleFunc("/actor", handleActor) diff --git a/main_test.go b/main_test.go index c4dbe99..20bbd84 100644 --- a/main_test.go +++ b/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" - keyloader "github.com/yukimochi/Activity-Relay/KeyLoader" - relayconf "github.com/yukimochi/Activity-Relay/RelayConf" + "github.com/yukimochi/Activity-Relay/KeyLoader" ) func TestMain(m *testing.M) { @@ -32,11 +30,11 @@ func TestMain(m *testing.M) { } macServer, _ = machinery.NewServer(macConfig) - Actor = activitypub.GenerateActor(hostname, &hostkey.PublicKey) - WebfingerResource = activitypub.GenerateWebfingerResource(hostname, &Actor) + Actor.GenerateSelfKey(hostname, &hostkey.PublicKey) + WebfingerResource.GenerateFromActor(hostname, &Actor) redClient.FlushAll().Result() - relConfig = relayconf.LoadConfig(redClient) + relConfig.Load(redClient) code := m.Run() os.Exit(code) } diff --git a/worker/worker.go b/worker/worker.go index 605db8c..933e9e3 100644 --- a/worker/worker.go +++ b/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,