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

Rename variables.

Browse Source
This commit is contained in:
Naoki Kosaka 2018-12-16 20:45:08 +09:00
parent c482673bc9
commit 2241d02fb2
5 changed files with 54 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
handle.go
View File

@ -91,7 +91,7 @@ func pushRelayJob(sourceInbox string, body []byte) {
},
},
}
_, err := macServer.SendTask(job)
_, err := machineryServer.SendTask(job)
if err != nil {
fmt.Fprintln(os.Stderr, err)
}
@ -116,7 +116,7 @@ func pushRegistorJob(inboxURL string, body []byte) {
},
},
}
_, err := macServer.SendTask(job)
_, err := machineryServer.SendTask(job)
if err != nil {
fmt.Fprintln(os.Stderr, err)
}
@ -182,7 +182,7 @@ func handleInbox(writer http.ResponseWriter, request *http.Request, activityDeco
case "Follow":
err = followAcceptable(activity, actor)
if err != nil {
resp := activity.GenerateResponse(hostname, "Reject")
resp := activity.GenerateResponse(hostURL, "Reject")
jsonData, _ := json.Marshal(&resp)
go pushRegistorJob(actor.Inbox, jsonData)
fmt.Println("Reject Follow Request : ", err.Error(), activity.Actor)
@ -192,7 +192,7 @@ func handleInbox(writer http.ResponseWriter, request *http.Request, activityDeco
} else {
if suitableFollow(activity, actor) {
if relayState.RelayConfig.ManuallyAccept {
redClient.HMSet("relay:pending:"+domain.Host, map[string]interface{}{
redisClient.HMSet("relay:pending:"+domain.Host, map[string]interface{}{
"inbox_url": actor.Endpoints.SharedInbox,
"activity_id": activity.ID,
"type": "Follow",
@ -201,7 +201,7 @@ func handleInbox(writer http.ResponseWriter, request *http.Request, activityDeco
})
fmt.Println("Pending Follow Request : ", activity.Actor)
} else {
resp := activity.GenerateResponse(hostname, "Accept")
resp := activity.GenerateResponse(hostURL, "Accept")
jsonData, _ := json.Marshal(&resp)
go pushRegistorJob(actor.Inbox, jsonData)
relayState.AddSubscription(state.Subscription{
@ -213,7 +213,7 @@ func handleInbox(writer http.ResponseWriter, request *http.Request, activityDeco
fmt.Println("Accept Follow Request : ", activity.Actor)
}
} else {
resp := activity.GenerateResponse(hostname, "Reject")
resp := activity.GenerateResponse(hostURL, "Reject")
jsonData, _ := json.Marshal(&resp)
go pushRegistorJob(actor.Inbox, jsonData)
fmt.Println("Reject Follow Request : ", activity.Actor)
@ -231,7 +231,7 @@ func handleInbox(writer http.ResponseWriter, request *http.Request, activityDeco
writer.WriteHeader(400)
writer.Write([]byte(err.Error()))
} else {
redClient.Del("relay:subscription:" + domain.Host)
redisClient.Del("relay:subscription:" + domain.Host)
fmt.Println("Accept Unfollow Request : ", activity.Actor)
writer.WriteHeader(202)
@ -265,7 +265,7 @@ func handleInbox(writer http.ResponseWriter, request *http.Request, activityDeco
}
switch nestedObject.Type {
case "Note":
resp := nestedObject.GenerateAnnounce(hostname)
resp := nestedObject.GenerateAnnounce(hostURL)
jsonData, _ := json.Marshal(&resp)
go pushRelayJob(domain.Host, jsonData)
fmt.Println("Accept Announce Note : ", activity.Actor)

22
handle_test.go
View File

@ -344,7 +344,7 @@ func TestHandleInboxValidFollow(t *testing.T) {
if r.StatusCode != 202 {
t.Fatalf("Failed - StatusCode is not 202 - " + strconv.Itoa(r.StatusCode))
}
res, _ := redClient.Exists("relay:subscription:" + domain.Host).Result()
res, _ := redisClient.Exists("relay:subscription:" + domain.Host).Result()
if res != 1 {
t.Fatalf("Failed - Subscription not works.")
}
@ -372,11 +372,11 @@ func TestHandleInboxValidManuallyFollow(t *testing.T) {
if r.StatusCode != 202 {
t.Fatalf("Failed - StatusCode is not 202 - " + strconv.Itoa(r.StatusCode))
}
res, _ := redClient.Exists("relay:pending:" + domain.Host).Result()
res, _ := redisClient.Exists("relay:pending:" + domain.Host).Result()
if res != 1 {
t.Fatalf("Failed - Pending not works.")
}
res, _ = redClient.Exists("relay:subscription:" + domain.Host).Result()
res, _ = redisClient.Exists("relay:subscription:" + domain.Host).Result()
if res != 0 {
t.Fatalf("Failed - Pending was skipped.")
}
@ -404,7 +404,7 @@ func TestHandleInboxInvalidFollow(t *testing.T) {
if r.StatusCode != 202 {
t.Fatalf("Failed - StatusCode is not 202 - " + strconv.Itoa(r.StatusCode))
}
res, _ := redClient.Exists("relay:subscription:" + domain.Host).Result()
res, _ := redisClient.Exists("relay:subscription:" + domain.Host).Result()
if res != 0 {
t.Fatalf("Failed - Subscription not blocked.")
}
@ -430,7 +430,7 @@ func TestHandleInboxValidFollowBlocked(t *testing.T) {
if r.StatusCode != 202 {
t.Fatalf("Failed - StatusCode is not 202 - " + strconv.Itoa(r.StatusCode))
}
res, _ := redClient.Exists("relay:subscription:" + domain.Host).Result()
res, _ := redisClient.Exists("relay:subscription:" + domain.Host).Result()
if res != 0 {
t.Fatalf("Failed - Subscription not blocked.")
}
@ -461,7 +461,7 @@ func TestHandleInboxValidUnfollow(t *testing.T) {
if r.StatusCode != 202 {
t.Fatalf("Failed - StatusCode is not 202 - " + strconv.Itoa(r.StatusCode))
}
res, _ := redClient.Exists("relay:subscription:" + domain.Host).Result()
res, _ := redisClient.Exists("relay:subscription:" + domain.Host).Result()
if res != 0 {
t.Fatalf("Failed - Subscription not succeed.")
}
@ -491,7 +491,7 @@ func TestHandleInboxInvalidUnfollow(t *testing.T) {
if r.StatusCode != 400 {
t.Fatalf("Failed - StatusCode is not 400")
}
res, _ := redClient.Exists("relay:subscription:" + domain.Host).Result()
res, _ := redisClient.Exists("relay:subscription:" + domain.Host).Result()
if res != 1 {
t.Fatalf("Failed - Block hacked unfollow not succeed.")
}
@ -521,7 +521,7 @@ func TestHandleInboxUnfollowAsActor(t *testing.T) {
if r.StatusCode != 400 {
t.Fatalf("Failed - StatusCode is not 400")
}
res, _ := redClient.Exists("relay:subscription:" + domain.Host).Result()
res, _ := redisClient.Exists("relay:subscription:" + domain.Host).Result()
if res != 1 {
t.Fatalf("Failed - Block actor unfollow not succeed.")
}
@ -557,8 +557,8 @@ func TestHandleInboxValidCreate(t *testing.T) {
}
relayState.DelSubscription(domain.Host)
relayState.DelSubscription("example.org")
redClient.Del("relay:subscription:" + domain.Host).Result()
redClient.Del("relay:subscription:example.org").Result()
redisClient.Del("relay:subscription:" + domain.Host).Result()
redisClient.Del("relay:subscription:example.org").Result()
}
func TestHandleInboxlimitedCreate(t *testing.T) {
@ -697,7 +697,7 @@ func TestHandleInboxUndo(t *testing.T) {
if r.StatusCode != 202 {
t.Fatalf("Failed - StatusCode is not 202 - " + strconv.Itoa(r.StatusCode))
}
res, _ := redClient.Exists("relay:subscription:" + domain.Host).Result()
res, _ := redisClient.Exists("relay:subscription:" + domain.Host).Result()
if res != 1 {
t.Fatalf("Failed - Missing unsubscribed.")
}

26
main.go
View File

@ -21,10 +21,10 @@ var Actor activitypub.Actor
// WebfingerResource : Relay's Webfinger resource
var WebfingerResource activitypub.WebfingerResource
var hostname *url.URL
var hostkey *rsa.PrivateKey
var redClient *redis.Client
var macServer *machinery.Server
var hostURL *url.URL
var hostPrivatekey *rsa.PrivateKey
var redisClient *redis.Client
var machineryServer *machinery.Server
var relayState state.RelayState
func main() {
@ -46,15 +46,15 @@ func main() {
}
var err error
hostkey, err = keyloader.ReadPrivateKeyRSAfromPath(pemPath)
hostPrivatekey, err = keyloader.ReadPrivateKeyRSAfromPath(pemPath)
if err != nil {
panic("Can't read Hostkey Pemfile")
}
hostname, err = url.Parse("https://" + relayDomain)
hostURL, err = url.Parse("https://" + relayDomain)
if err != nil {
panic("Can't parse Relay Domain")
}
redClient = redis.NewClient(&redis.Options{
redisClient = redis.NewClient(&redis.Options{
Addr: redisURL,
})
@ -65,16 +65,16 @@ func main() {
ResultsExpireIn: 5,
}
macServer, err = machinery.NewServer(macConfig)
machineryServer, err = machinery.NewServer(macConfig)
if err != nil {
fmt.Fprintln(os.Stderr, err)
}
Actor.GenerateSelfKey(hostname, &hostkey.PublicKey)
WebfingerResource.GenerateFromActor(hostname, &Actor)
Actor.GenerateSelfKey(hostURL, &hostPrivatekey.PublicKey)
WebfingerResource.GenerateFromActor(hostURL, &Actor)
// Load Config
relayState = state.NewState(redClient)
relayState = state.NewState(redisClient)
http.HandleFunc("/.well-known/webfinger", handleWebfinger)
http.HandleFunc("/actor", handleActor)
@ -87,12 +87,12 @@ func main() {
fmt.Println("REDIS URL : ", redisURL)
fmt.Println("BIND ADDRESS : ", relayBind)
fmt.Println(" - Blocked Domain")
domains, _ := redClient.HKeys("relay:config:blockedDomain").Result()
domains, _ := redisClient.HKeys("relay:config:blockedDomain").Result()
for _, domain := range domains {
fmt.Println(domain)
}
fmt.Println(" - Limited Domain")
domains, _ = redClient.HKeys("relay:config:limitedDomain").Result()
domains, _ = redisClient.HKeys("relay:config:limitedDomain").Result()
for _, domain := range domains {
fmt.Println(domain)
}

18
main_test.go
View File

@ -18,9 +18,9 @@ func TestMain(m *testing.M) {
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{
hostPrivatekey, _ = keyloader.ReadPrivateKeyRSAfromPath(pemPath)
hostURL, _ = url.Parse("https://" + relayDomain)
redisClient = redis.NewClient(&redis.Options{
Addr: redisURL,
})
var macConfig = &config.Config{
@ -29,15 +29,15 @@ func TestMain(m *testing.M) {
ResultBackend: "redis://" + redisURL,
ResultsExpireIn: 5,
}
macServer, _ = machinery.NewServer(macConfig)
machineryServer, _ = machinery.NewServer(macConfig)
Actor.GenerateSelfKey(hostname, &hostkey.PublicKey)
WebfingerResource.GenerateFromActor(hostname, &Actor)
Actor.GenerateSelfKey(hostURL, &hostPrivatekey.PublicKey)
WebfingerResource.GenerateFromActor(hostURL, &Actor)
// Load Config
redClient.FlushAll().Result()
relayState = state.NewState(redClient)
redisClient.FlushAll().Result()
relayState = state.NewState(redisClient)
code := m.Run()
os.Exit(code)
redClient.FlushAll().Result()
redisClient.FlushAll().Result()
}

30
worker/worker.go
View File

@ -15,26 +15,22 @@ import (
"github.com/yukimochi/Activity-Relay/KeyLoader"
)
// Hostname : Hostname of Relay
var Hostname *url.URL
// Hostkey : PrivateKey of Relay
var Hostkey *rsa.PrivateKey
// Actor : Relay's Actor
var Actor activitypub.Actor
var redClient *redis.Client
var hostURL *url.URL
var hostPrivatekey *rsa.PrivateKey
var redisClient *redis.Client
func relayActivity(args ...string) error {
inboxURL := args[0]
body := args[1]
err := activitypub.SendActivity(inboxURL, Actor.ID, []byte(body), Hostkey)
err := activitypub.SendActivity(inboxURL, Actor.ID, []byte(body), hostPrivatekey)
if err != nil {
domain, _ := url.Parse(inboxURL)
mod, _ := redClient.HSetNX("relay:statistics:"+domain.Host, "last_error", err.Error()).Result()
mod, _ := redisClient.HSetNX("relay:statistics:"+domain.Host, "last_error", err.Error()).Result()
if mod {
redClient.Expire("relay:statistics:"+domain.Host, time.Duration(time.Minute))
redisClient.Expire("relay:statistics:"+domain.Host, time.Duration(time.Minute))
}
}
return err
@ -43,7 +39,7 @@ func relayActivity(args ...string) error {
func registorActivity(args ...string) error {
inboxURL := args[0]
body := args[1]
err := activitypub.SendActivity(inboxURL, Actor.ID, []byte(body), Hostkey)
err := activitypub.SendActivity(inboxURL, Actor.ID, []byte(body), hostPrivatekey)
return err
}
@ -62,26 +58,26 @@ func main() {
}
var err error
Hostkey, err = keyloader.ReadPrivateKeyRSAfromPath(pemPath)
hostPrivatekey, err = keyloader.ReadPrivateKeyRSAfromPath(pemPath)
if err != nil {
panic("Can't read Hostkey Pemfile")
}
Hostname, err = url.Parse("https://" + relayDomain)
hostURL, err = url.Parse("https://" + relayDomain)
if err != nil {
panic("Can't parse Relay Domain")
}
redClient = redis.NewClient(&redis.Options{
redisClient = redis.NewClient(&redis.Options{
Addr: redisURL,
})
Actor.GenerateSelfKey(Hostname, &Hostkey.PublicKey)
Actor.GenerateSelfKey(hostURL, &hostPrivatekey.PublicKey)
var macConfig = &config.Config{
machineryConfig := &config.Config{
Broker: "redis://" + redisURL,
DefaultQueue: "relay",
ResultBackend: "redis://" + redisURL,
ResultsExpireIn: 5,
}
server, err := machinery.NewServer(macConfig)
server, err := machinery.NewServer(machineryConfig)
if err != nil {
panic(err.Error())
}