Use viper as Configuration manager. (#11)

* Use viper in CLI.

* Use viper in Server.

* Use viper in Worker.

worker/sender.go

@@ -0,0 +1,53 @@
+package main
+
+import (
+	"bytes"
+	"crypto/rsa"
+	"crypto/sha256"
+	"encoding/base64"
+	"errors"
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/Songmu/go-httpdate"
+	"github.com/yukimochi/httpsig"
+)
+
+func appendSignature(request *http.Request, body *[]byte, KeyID string, publicKey *rsa.PrivateKey) error {
+	hash := sha256.New()
+	hash.Write(*body)
+	b := hash.Sum(nil)
+	request.Header.Set("Digest", "SHA-256="+base64.StdEncoding.EncodeToString(b))
+	request.Header.Set("Host", request.Host)
+
+	signer, _, err := httpsig.NewSigner([]httpsig.Algorithm{httpsig.RSA_SHA256}, []string{httpsig.RequestTarget, "Host", "Date", "Digest", "Content-Type"}, httpsig.Signature)
+	if err != nil {
+		return err
+	}
+	err = signer.SignRequest(publicKey, KeyID, request)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func sendActivity(inboxURL string, KeyID string, body []byte, publicKey *rsa.PrivateKey) error {
+	req, _ := http.NewRequest("POST", inboxURL, bytes.NewBuffer(body))
+	req.Header.Set("Content-Type", "application/activity+json, application/ld+json")
+	req.Header.Set("User-Agent", uaString)
+	req.Header.Set("Date", httpdate.Time2Str(time.Now()))
+	appendSignature(req, &body, KeyID, publicKey)
+	client := &http.Client{Timeout: time.Duration(5) * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return err
+	}
+
+	fmt.Println(inboxURL, resp.StatusCode)
+	if resp.StatusCode/100 != 2 {
+		return errors.New(resp.Status)
+	}
+
+	return nil
+}

worker/worker.go

@@ -11,6 +11,7 @@ import (
 	"github.com/RichardKnop/machinery/v1/config"
 	"github.com/go-redis/redis"
 	"github.com/satori/go.uuid"
+	"github.com/spf13/viper"
 	"github.com/yukimochi/Activity-Relay/ActivityPub"
 	"github.com/yukimochi/Activity-Relay/KeyLoader"
 )
@@ -20,12 +21,14 @@ var Actor activitypub.Actor
 
 var hostURL *url.URL
 var hostPrivatekey *rsa.PrivateKey
+var machineryServer *machinery.Server
 var redisClient *redis.Client
+var uaString string
 
 func relayActivity(args ...string) error {
 	inboxURL := args[0]
 	body := args[1]
-	err := activitypub.SendActivity(inboxURL, Actor.ID, []byte(body), hostPrivatekey)
+	err := sendActivity(inboxURL, Actor.ID, []byte(body), hostPrivatekey)
 	if err != nil {
 		domain, _ := url.Parse(inboxURL)
 		mod, _ := redisClient.HSetNX("relay:statistics:"+domain.Host, "last_error", err.Error()).Result()
@@ -39,63 +42,48 @@ func relayActivity(args ...string) error {
 func registorActivity(args ...string) error {
 	inboxURL := args[0]
 	body := args[1]
-	err := activitypub.SendActivity(inboxURL, Actor.ID, []byte(body), hostPrivatekey)
+	err := sendActivity(inboxURL, Actor.ID, []byte(body), hostPrivatekey)
 	return err
 }
 
-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
-	hostPrivatekey, err = keyloader.ReadPrivateKeyRSAfromPath(pemPath)
-	if err != nil {
-		panic("Can't read Hostkey Pemfile")
-	}
-	hostURL, err = url.Parse("https://" + relayDomain)
-	if err != nil {
-		panic("Can't parse Relay Domain")
-	}
+func initConfig() {
+	viper.BindEnv("actor_pem")
+	viper.BindEnv("relay_domain")
+	viper.BindEnv("relay_servicename")
+	viper.BindEnv("redis_url")
+	hostURL, _ = url.Parse("https://" + viper.GetString("relay_domain"))
+	hostPrivatekey, _ = keyloader.ReadPrivateKeyRSAfromPath(viper.GetString("actor_pem"))
 	redisClient = redis.NewClient(&redis.Options{
-		Addr: redisURL,
+		Addr: viper.GetString("redis_url"),
 	})
-	Actor.GenerateSelfKey(hostURL, &hostPrivatekey.PublicKey)
-
 	machineryConfig := &config.Config{
-		Broker:          "redis://" + redisURL,
+		Broker:          "redis://" + viper.GetString("redis_url"),
 		DefaultQueue:    "relay",
-		ResultBackend:   "redis://" + redisURL,
+		ResultBackend:   "redis://" + viper.GetString("redis_url"),
 		ResultsExpireIn: 5,
 	}
-	server, err := machinery.NewServer(machineryConfig)
+	machineryServer, _ = machinery.NewServer(machineryConfig)
+	uaString = viper.GetString("relay_servicename") + " (golang net/http; Activity-Relay v0.2.0rc2; " + hostURL.Host + ")"
+	Actor.GenerateSelfKey(hostURL, &hostPrivatekey.PublicKey)
+
+	fmt.Println("Welcome to YUKIMOCHI Activity-Relay [Worker]\n - Configrations")
+	fmt.Println("RELAY DOMAIN : ", hostURL.Host)
+	fmt.Println("REDIS URL : ", viper.GetString("redis_url"))
+}
+
+func main() {
+	initConfig()
+
+	err := machineryServer.RegisterTask("registor", registorActivity)
 	if err != nil {
 		panic(err.Error())
 	}
-	err = server.RegisterTask("registor", registorActivity)
-	if err != nil {
-		panic(err.Error())
-	}
-	err = server.RegisterTask("relay", relayActivity)
+	err = machineryServer.RegisterTask("relay", relayActivity)
 	if err != nil {
 		panic(err.Error())
 	}
 	workerID := uuid.NewV4()
-	worker := server.NewWorker(workerID.String(), 200)
-
-	fmt.Println("Welcome to YUKIMOCHI Activity-Relay [Worker]\n - Configrations")
-	fmt.Println("RELAY DOMAIN : ", relayDomain)
-	fmt.Println("REDIS URL : ", redisURL)
-
+	worker := machineryServer.NewWorker(workerID.String(), 200)
 	err = worker.Launch()
 	if err != nil {
 		fmt.Fprintln(os.Stderr, err)