skeh/Activity-Relay
1
0
Fork 0
Code Issues3 Pull requests Projects Releases Packages Wiki Activity

Use viper in CLI.

Browse source
This commit is contained in:
Naoki Kosaka 2018-12-23 12:56:29 +09:00
parent 93a00a13e2
commit 863f3db9ef
4 changed files with 163 additions and 92 deletions

63
cli/cli.go
View file

@ -2,24 +2,41 @@ package main
import (
"crypto/rsa"
"fmt"
"net/url"
"os"
"github.com/RichardKnop/machinery/v1"
"github.com/RichardKnop/machinery/v1/config"
"github.com/go-redis/redis"
"github.com/spf13/cobra"
"github.com/spf13/viper"
"github.com/yukimochi/Activity-Relay/KeyLoader"
"github.com/yukimochi/Activity-Relay/State"
)
var hostname *url.URL
var hostkey *rsa.PrivateKey
var redClient *redis.Client
var macServer *machinery.Server
var relayState state.RelayState
func initConfig() {
viper.BindEnv("actor_pem")
viper.BindEnv("relay_domain")
viper.BindEnv("redis_url")
hostkey, _ = keyloader.ReadPrivateKeyRSAfromPath(viper.GetString("actor_pem"))
hostname, _ = url.Parse("https://" + viper.GetString("relay_domain"))
redClient := redis.NewClient(&redis.Options{
Addr: viper.GetString("redis_url"),
})
var macConfig = &config.Config{
Broker: "redis://" + viper.GetString("redis_url"),
DefaultQueue: "relay",
ResultBackend: "redis://" + viper.GetString("redis_url"),
ResultsExpireIn: 5,
}
macServer, _ = machinery.NewServer(macConfig)
relayState = state.NewState(redClient)
}
func buildNewCmd() *cobra.Command {
var app = &cobra.Command{}
app.AddCommand(domainCmdInit())
@ -29,45 +46,7 @@ func buildNewCmd() *cobra.Command {
}
func main() {
pemPath := os.Getenv("ACTOR_PEM")
if pemPath == "" {
panic("Require ACTOR_PEM environment variable.")
}
relayDomain := os.Getenv("RELAY_DOMAIN")
if relayDomain == "" {
panic("Require RELAY_DOMAIN environment variable.")
}
redisURL := os.Getenv("REDIS_URL")
if redisURL == "" {
redisURL = "127.0.0.1:6379"
}
var err error
hostkey, err = keyloader.ReadPrivateKeyRSAfromPath(pemPath)
if err != nil {
panic("Can't read Hostkey Pemfile")
}
hostname, err = url.Parse("https://" + relayDomain)
if err != nil {
panic("Can't parse Relay Domain")
}
redClient = redis.NewClient(&redis.Options{
Addr: redisURL,
})
var macConfig = &config.Config{
Broker: "redis://" + redisURL,
DefaultQueue: "relay",
ResultBackend: "redis://" + redisURL,
ResultsExpireIn: 5,
}
macServer, err = machinery.NewServer(macConfig)
if err != nil {
fmt.Fprintln(os.Stderr, err)
}
relayState = state.NewState(redClient)
initConfig()
var app = buildNewCmd()
app.Execute()
}

33
cli/cli_test.go
View file

@ -1,38 +1,19 @@
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"
"github.com/yukimochi/Activity-Relay/State"
"github.com/spf13/viper"
)
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()
relayState = state.NewState(redClient)
viper.Set("Actor_pem", "misc/testKey.pem")
viper.Set("Relay_domain", "relay.yukimochi.example.org")
initConfig()
relayState.RedisClient.FlushAll().Result()
code := m.Run()
os.Exit(code)
redClient.FlushAll().Result()
relayState.RedisClient.FlushAll().Result()
}

48
cli/follow.go
View file

@ -23,7 +23,7 @@ func followCmdInit() *cobra.Command {
Use: "list",
Short: "List follow request",
Long: "List follow request.",
RunE: listFollowsC,
RunE: listFollows,
}
follow.AddCommand(followList)
@ -32,7 +32,7 @@ func followCmdInit() *cobra.Command {
Short: "Accept follow request",
Long: "Accept follow request by domain.",
Args: cobra.MinimumNArgs(1),
RunE: acceptFollowC,
RunE: acceptFollow,
}
follow.AddCommand(followAccept)
@ -41,7 +41,7 @@ func followCmdInit() *cobra.Command {
Short: "Reject follow request",
Long: "Reject follow request by domain.",
Args: cobra.MinimumNArgs(1),
RunE: rejectFollowC,
RunE: rejectFollow,
}
follow.AddCommand(followReject)
@ -71,24 +71,6 @@ func pushRegistorJob(inboxURL string, body []byte) {
}
}
func listFollowsC(cmd *cobra.Command, args []string) error {
var domains []string
cmd.Println(" - Follow request :")
follows, err := relayState.RedisClient.Keys("relay:pending:*").Result()
if err != nil {
return err
}
for _, follow := range follows {
domains = append(domains, strings.Replace(follow, "relay:pending:", "", 1))
}
for _, domain := range domains {
cmd.Println(domain)
}
cmd.Println(fmt.Sprintf("Total : %d", len(domains)))
return nil
}
func createFollowRequestResponse(domain string, response string) error {
data, err := relayState.RedisClient.HGetAll("relay:pending:" + domain).Result()
if err != nil {
@ -118,7 +100,25 @@ func createFollowRequestResponse(domain string, response string) error {
return nil
}
func acceptFollowC(cmd *cobra.Command, args []string) error {
func listFollows(cmd *cobra.Command, args []string) error {
var domains []string
cmd.Println(" - Follow request :")
follows, err := relayState.RedisClient.Keys("relay:pending:*").Result()
if err != nil {
return err
}
for _, follow := range follows {
domains = append(domains, strings.Replace(follow, "relay:pending:", "", 1))
}
for _, domain := range domains {
cmd.Println(domain)
}
cmd.Println(fmt.Sprintf("Total : %d", len(domains)))
return nil
}
func acceptFollow(cmd *cobra.Command, args []string) error {
var err error
var domains []string
follows, err := relayState.RedisClient.Keys("relay:pending:*").Result()
@ -143,10 +143,10 @@ func acceptFollowC(cmd *cobra.Command, args []string) error {
return nil
}
func rejectFollowC(cmd *cobra.Command, args []string) error {
func rejectFollow(cmd *cobra.Command, args []string) error {
var err error
var domains []string
follows, err := redClient.Keys("relay:pending:*").Result()
follows, err := relayState.RedisClient.Keys("relay:pending:*").Result()
if err != nil {
return err
}

111
cli/follow_test.go Normal file
View file

@ -0,0 +1,111 @@
package main
import (
"bytes"
"strings"
"testing"
)
func TestListFollows(t *testing.T) {
app := buildNewCmd()
buffer := new(bytes.Buffer)
app.SetOutput(buffer)
relayState.RedisClient.HMSet("relay:pending:example.com", map[string]interface{}{
"inbox_url": "https://example.com/inbox",
"activity_id": "https://example.com/UUID",
"type": "Follow",
"actor": "https://example.com/user/example",
"object": "https://" + hostname.Host + "/actor",
})
app.SetArgs([]string{"follow", "list"})
app.Execute()
output := buffer.String()
valid := ` - Follow request :
example.com
Total : 1
`
if output != valid {
t.Fatalf("Invalid Responce.")
}
relayState.RedisClient.FlushAll().Result()
relayState.Load()
}
func TestAcceptFollow(t *testing.T) {
app := buildNewCmd()
relayState.RedisClient.HMSet("relay:pending:example.com", map[string]interface{}{
"inbox_url": "https://example.com/inbox",
"activity_id": "https://example.com/UUID",
"type": "Follow",
"actor": "https://example.com/user/example",
"object": "https://" + hostname.Host + "/actor",
})
app.SetArgs([]string{"follow", "accept", "example.com"})
app.Execute()
valid, _ := relayState.RedisClient.Exists("relay:pending:example.com").Result()
if valid != 0 {
t.Fatalf("Not removed follow request.")
}
valid, _ = relayState.RedisClient.Exists("relay:subscription:example.com").Result()
if valid != 1 {
t.Fatalf("Not created subscription.")
}
relayState.RedisClient.FlushAll().Result()
relayState.Load()
}
func TestRejectFollow(t *testing.T) {
app := buildNewCmd()
relayState.RedisClient.HMSet("relay:pending:example.com", map[string]interface{}{
"inbox_url": "https://example.com/inbox",
"activity_id": "https://example.com/UUID",
"type": "Follow",
"actor": "https://example.com/user/example",
"object": "https://" + hostname.Host + "/actor",
})
app.SetArgs([]string{"follow", "reject", "example.com"})
app.Execute()
valid, _ := relayState.RedisClient.Exists("relay:pending:example.com").Result()
if valid != 0 {
t.Fatalf("No response follow request.")
}
valid, _ = relayState.RedisClient.Exists("relay:subscription:example.com").Result()
if valid != 0 {
t.Fatalf("Created subscription.")
}
relayState.RedisClient.FlushAll().Result()
relayState.Load()
}
func TestInvalidFollow(t *testing.T) {
app := buildNewCmd()
buffer := new(bytes.Buffer)
app.SetOutput(buffer)
app.SetArgs([]string{"follow", "accept", "unknown.tld"})
app.Execute()
output := buffer.String()
if strings.Split(output, "\n")[0] != "Invalid domain given" {
t.Fatalf("Invalid Responce.")
}
relayState.RedisClient.FlushAll().Result()
relayState.Load()
}