lilfade/Activity-Relay
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity

Refactoring-1811

Browse Source
This commit is contained in:
Naoki Kosaka 2018-11-25 23:40:21 +09:00
parent 4c84636b29
commit 2e883d9aed
16 changed files with 406 additions and 200 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

114
ActivityPub/activity.go
View File

@ -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,
}
}

121
ActivityPub/models.go
View File

@ -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,
},
}
}

9
Gopkg.lock generated
View File

@ -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",

3
KeyLoader/keyloader.go
View File

@ -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 {

45
RelayConf/relayconf.go
View File

@ -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)
}
}

2
cli/cli.go
View File

@ -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")

36
cli/cli_test.go Normal file
View File

@ -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)
}

26
cli/config.go
View File

@ -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)
}

156
cli/config_test.go Normal file
View File

@ -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.")
}
}
}
}

10
cli/follow.go
View File

@ -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)

3
decode.go
View File

@ -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
}

17
handle.go
View File

@ -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)

39
handle_test.go
View File

@ -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) {

6
main.go
View File

@ -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)

12
main_test.go
View File

@ -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)
}

7
worker/worker.go
View File

@ -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,