Skip to content

Commit

Permalink
extract config stuff.
Browse files Browse the repository at this point in the history
nice ui look.
  • Loading branch information
adelolmo committed May 29, 2019
1 parent 0da8888 commit 95967c8
Show file tree
Hide file tree
Showing 6 changed files with 174 additions and 116 deletions.
104 changes: 104 additions & 0 deletions config/configuration.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,104 @@
package config

import (
"bufio"
"encoding/json"
"errors"
"fmt"
"github.com/adelolmo/delauncher/crypt"
"log"
"os"
"os/user"
"path/filepath"
)

const (
configDir string = ".config/delauncher"
configFile string = "config.json"
)

type Config struct {
Filename string
Key crypt.Key
}

type delugeConfig struct {
ServerUrl string `json:"serverUrl"`
Password []byte `json:"password"`
}

type Properties struct {
ServerUrl, Password string
}

func NewConfig(key crypt.Key) Config {
return Config{
Filename: filepath.Join(getHome(), configDir, configFile),
Key: key,
}
}

func (c Config) Get() (Properties, error) {
if err := os.MkdirAll(filepath.Join(getHome(), configDir), 0755); err != nil {
fmt.Printf("Cannot create directory %s in home %s. Error: %s", c.Filename, getHome(), err)
}
if _, err := os.Stat(c.Filename); os.IsNotExist(err) {
return Properties{}, err
}

configFile, err := os.OpenFile(c.Filename, os.O_RDONLY, 0700)
if err != nil {
return Properties{}, fmt.Errorf("cannot open file %s. Error: %s", c.Filename, err)
}

r := bufio.NewReader(configFile)
var config delugeConfig
if err := json.NewDecoder(r).Decode(&config); err != nil {
return Properties{}, errors.New("cannot deserialize configuration")
}

result, err := c.Key.Decrypt(config.Password)
if err != nil {
return Properties{}, errors.New("cannot decrypt password")
}
password := string(result[:])

err = configFile.Close()
if err != nil {
return Properties{}, fmt.Errorf("cannot close file %s. Error: %s", c.Filename, err)
}

return Properties{ServerUrl: config.ServerUrl, Password: password}, nil
}

func (c Config) Save(serverUrl, password string) {
f, err := os.Create(c.Filename)
if err != nil {
panic(err)
}
w := bufio.NewWriter(f)

encryptedPassword, err := c.Key.Encrypt([]byte(password))
if err != nil {
log.Fatal(err)
}
config := &delugeConfig{ServerUrl: serverUrl, Password: encryptedPassword}
if err = json.NewEncoder(w).Encode(&config); err != nil {
log.Fatalf("Cannot encode json configuration. Error: %s", err)
}
if err = w.Flush(); err != nil {
log.Fatalf("Cannot flush into file %s. Error: %s", f.Name(), err)
}

if err = f.Close(); err != nil {
log.Fatalf("Cannot close file %s. Error: %s", c.Filename, err)
}
}

func getHome() string {
usr, err := user.Current()
if err != nil {
log.Fatal(err)
}
return usr.HomeDir
}
12 changes: 8 additions & 4 deletions crypt/aes.go
Original file line number Diff line number Diff line change
Expand Up @@ -10,8 +10,12 @@ import (
"io"
)

func Encrypt(key, text []byte) ([]byte, error) {
block, err := aes.NewCipher(key)
type Key struct {
Value []byte
}

func (k Key) Encrypt(text []byte) ([]byte, error) {
block, err := aes.NewCipher(k.Value)
if err != nil {
return nil, err
}
Expand All @@ -26,8 +30,8 @@ func Encrypt(key, text []byte) ([]byte, error) {
return cipherText, nil
}

func Decrypt(key, text []byte) ([]byte, error) {
block, err := aes.NewCipher(key)
func (k Key) Decrypt(text []byte) ([]byte, error) {
block, err := aes.NewCipher(k.Value)
if err != nil {
return nil, err
}
Expand Down
10 changes: 7 additions & 3 deletions magnet/deluge.go
Original file line number Diff line number Diff line change
Expand Up @@ -10,10 +10,14 @@ type Link struct {
Address string
}

func (link Link) Add(serverUrl, password string) error {
client := delugeclient.NewDeluge(serverUrl, password)
type Server struct {
Url, Password string
}

func (server Server) Add(link Link) error {
client := delugeclient.NewDeluge(server.Url, server.Password)
if err := client.Connect(); err != nil {
return fmt.Errorf("unable to stablish connection to server %s", serverUrl)
return fmt.Errorf("unable to stablish connection to server %s", server.Url)
}
if err := client.AddMagnet(link.Address); err != nil {
return fmt.Errorf("unable to add magnet link %s", link.Address)
Expand Down
146 changes: 38 additions & 108 deletions main.go
Original file line number Diff line number Diff line change
@@ -1,36 +1,26 @@
package main

import (
"bufio"
"bytes"
"encoding/json"
"fmt"
"github.com/adelolmo/delauncher/config"
"github.com/adelolmo/delauncher/crypt"
"github.com/adelolmo/delauncher/magnet"
"github.com/adelolmo/delauncher/notifications"
"github.com/andlabs/ui"
"log"
"os"
"os/exec"
"os/user"
"path/filepath"
)

const (
ConfigDir string = ".config/delauncher"
ConfigFile string = "config.json"
)

var SecretKey = []byte{11, 22, 33, 44, 55, 66, 77, 88, 99, 00, 11, 22, 33, 44, 55, 66}

type DelugeConfig struct {
ServerUrl string
Password []byte
var secretKey = []byte{11, 22, 33, 44, 55, 66, 77, 88, 99, 00, 11, 22, 33, 44, 55, 66}
var key = crypt.Key{
Value: secretKey,
}

var conf = config.NewConfig(key)

func main() {
switch len(os.Args) {
case 1:
config()
configure()
case 2:
addMagnet(magnet.Link{
Address: os.Args[1],
Expand All @@ -41,101 +31,36 @@ func main() {
}
}

func addMagnet(magnetLink magnet.Link) {
serverUrl, password := getConfig(filepath.Join(getHome(), ConfigDir, ConfigFile))
if err := magnetLink.Add(serverUrl, password); err != nil {
fmt.Printf(err.Error())
notify(err.Error())
os.Exit(2)
}
notify(fmt.Sprintf("Magnet added:\n%s", magnetLink.Name()))
}

func getHome() string {
usr, err := user.Current()
if err != nil {
log.Fatal(err)
}
return usr.HomeDir
}

func getConfig(configFilename string) (string, string) {

if err := os.MkdirAll(filepath.Join(getHome(), ConfigDir), 0755); err != nil {
fmt.Printf("Cannot create directory %s in home %s. Error: %s", configFilename, getHome(), err)
}
if _, err := os.Stat(configFilename); os.IsNotExist(err) {
return "", ""
}

configFile, err := os.OpenFile(configFilename, os.O_RDONLY, 0700)
func configure() {
configProperties, err := conf.Get()
if err != nil {
fmt.Printf("Cannot open cache file %s. Error: %s", configFilename, err)
}

r := bufio.NewReader(configFile)
var config DelugeConfig
if err := json.NewDecoder(r).Decode(&config); err != nil {
panic(err)
}

result, err := crypt.Decrypt(SecretKey, config.Password)
if err != nil {
log.Fatal("Cannot decrypt secret")
}
password := string(result[:])

err = configFile.Close()
if err != nil {
log.Fatalf("Cannot close file %s. Error: %s", configFilename, err)
notifications.Message(fmt.Sprintf("Unable to read configuration. Error %s", err.Error()))
os.Exit(1)
}

return config.ServerUrl, password
}

func config() {
err := ui.Main(func() {
configFilename := filepath.Join(getHome(), ConfigDir, ConfigFile)
serverUrl, password := getConfig(configFilename)

err = ui.Main(func() {
serverUrlField := ui.NewEntry()
serverUrlField.SetText(configProperties.ServerUrl)
passwordField := ui.NewPasswordEntry()
passwordField.SetText(configProperties.Password)
saveButton := ui.NewButton("Save")
quitButton := ui.NewButton("Quit")

serverUrlField.SetText(serverUrl)
passwordField.SetText(password)

button := ui.NewButton("Save & Quit")
box := ui.NewVerticalBox()
box.Append(ui.NewLabel("Deluge server URL:"), false)
box.Append(serverUrlField, false)
box.Append(ui.NewLabel("Password:"), false)
box.Append(passwordField, false)
box.Append(button, false)
buttonsBox := ui.NewHorizontalBox()
buttonsBox.Append(saveButton, true)
buttonsBox.Append(quitButton, true)
box.Append(buttonsBox, false)
window := ui.NewWindow("Delauncher", 400, 150, false)
window.SetMargined(true)
window.SetChild(box)
button.OnClicked(func(*ui.Button) {
f, err := os.Create(configFilename)
if err != nil {
panic(err)
}
w := bufio.NewWriter(f)

encryptedPassword, err := crypt.Encrypt(SecretKey, []byte(passwordField.Text()))
if err != nil {
log.Fatal(err)
}
config := &DelugeConfig{ServerUrl: serverUrlField.Text(), Password: encryptedPassword}
if err = json.NewEncoder(w).Encode(&config); err != nil {
log.Fatalf("Cannot encode json configuration. Error: %s", err)
}
if err = w.Flush(); err != nil {
log.Fatalf("Cannot flush into file %s. Error: %s", f.Name(), err)
}

if err = f.Close(); err != nil {
log.Fatalf("Cannot close file %s. Error: %s", configFilename, err)
}

saveButton.OnClicked(func(*ui.Button) {
conf.Save(serverUrlField.Text(), passwordField.Text())
})
quitButton.OnClicked(func(*ui.Button) {
ui.Quit()
})
window.OnClosing(func(*ui.Window) bool {
Expand All @@ -149,12 +74,17 @@ func config() {
}
}

func notify(message string) {
cmd := exec.Command("notify-send", "Deluge", message, "--icon=delauncher")
cmdOutput := &bytes.Buffer{}
cmd.Stdout = cmdOutput
if err := cmd.Run(); err != nil {
fmt.Printf("==> Error: %s\n", err.Error())
os.Exit(3)
func addMagnet(magnetLink magnet.Link) {
configValues, err := conf.Get()
if err != nil {
notifications.Message(fmt.Sprintf("Unable to read configuration. Error %s", err.Error()))
os.Exit(1)
}
var server = magnet.Server{Url: configValues.ServerUrl, Password: configValues.Password}
if err := server.Add(magnetLink); err != nil {
fmt.Printf(err.Error())
notifications.Message(err.Error())
os.Exit(2)
}
notifications.Message(fmt.Sprintf("Magnet added:\n%s", magnetLink.Name()))
}
16 changes: 16 additions & 0 deletions notifications/notify.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,16 @@
package notifications

import (
"bytes"
"log"
"os/exec"
)

func Message(message string) {
cmd := exec.Command("notify-send", "Deluge", message, "--icon=delauncher")
cmdOutput := &bytes.Buffer{}
cmd.Stdout = cmdOutput
if err := cmd.Run(); err != nil {
log.Fatalf("unable to send notification: %s", err.Error())
}
}
2 changes: 1 addition & 1 deletion package
Original file line number Diff line number Diff line change
Expand Up @@ -3,7 +3,7 @@
BUILD=build
version=$(cat VERSION)
architecture=amd64
default_key=$(grep "var SecretKey" main.go | grep "[,0-9]")
default_key=$(grep "var secretKey" main.go | grep "[,0-9]")
echo $default_key
secret_key=$(cat secret)
echo $secret_key
Expand Down

0 comments on commit 95967c8

Please sign in to comment.