138 lines
2.9 KiB
Go
138 lines
2.9 KiB
Go
// Command lsf provides functions to use the lsf with the commandline.
|
|
package main
|
|
|
|
import (
|
|
"flag"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"log"
|
|
"os"
|
|
"path"
|
|
"strings"
|
|
"syscall"
|
|
|
|
"git.marceltransier.de/lsf"
|
|
"github.com/pkg/errors"
|
|
"golang.org/x/crypto/ssh/terminal"
|
|
)
|
|
|
|
var (
|
|
sessionCache string
|
|
username string
|
|
)
|
|
|
|
func init() {
|
|
homeDir, err := os.UserHomeDir()
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
defaultCacheDir := path.Join(homeDir, ".cache/go-lsf/sessions")
|
|
flag.StringVar(&sessionCache, "session-cache", defaultCacheDir, "path where the session tokens are located")
|
|
flag.StringVar(&username, "username", "", "username to login with in lsf")
|
|
flag.Parse()
|
|
|
|
err = os.MkdirAll(sessionCache, os.ModePerm)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func main() {
|
|
if len(username) == 0 {
|
|
var err error
|
|
username, err = readUsername()
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
}
|
|
|
|
s, err := session(username)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
|
|
fmt.Printf("s: %+v\n", s)
|
|
}
|
|
|
|
func readUsername() (string, error) {
|
|
var username string
|
|
fmt.Print("Username: ")
|
|
_, err := fmt.Scanf("%s", &username)
|
|
if err != nil {
|
|
return "", errors.Wrap(err, "could not read username")
|
|
}
|
|
return username, nil
|
|
}
|
|
|
|
func readPassword() (string, error) {
|
|
var password string
|
|
fmt.Print("Password: ")
|
|
b, err := terminal.ReadPassword(int(syscall.Stdin))
|
|
if err != nil {
|
|
return "", errors.Wrap(err, "could not read password")
|
|
}
|
|
fmt.Print("\n")
|
|
password = string(b)
|
|
return password, nil
|
|
}
|
|
|
|
func session(username string) (*lsf.Session, error) {
|
|
sessionPath := path.Join(sessionCache, username)
|
|
sessionFile, err := os.Open(sessionPath)
|
|
if err != nil {
|
|
pErr, ok := err.(*os.PathError)
|
|
if !ok {
|
|
return nil, err
|
|
}
|
|
errno, ok := pErr.Unwrap().(syscall.Errno)
|
|
if !ok {
|
|
return nil, err
|
|
}
|
|
if errno != syscall.ENOENT {
|
|
log.Fatal(err)
|
|
}
|
|
log.Printf("no session for %s cached\n", username)
|
|
return login(username)
|
|
}
|
|
defer sessionFile.Close()
|
|
|
|
b, err := ioutil.ReadAll(sessionFile)
|
|
if err != nil {
|
|
return nil, errors.Wrapf(err, "could not read session file %s", sessionPath)
|
|
}
|
|
sid := strings.TrimSuffix(string(b), "\n")
|
|
s := &lsf.Session{
|
|
SID: sid,
|
|
}
|
|
valid, err := s.Valid()
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not check session")
|
|
}
|
|
if !valid {
|
|
fmt.Println("session is not valid")
|
|
err := os.Remove(sessionPath)
|
|
if err != nil {
|
|
log.Println(errors.Wrap(err, "could not remove invalid session file"))
|
|
}
|
|
return login(username)
|
|
}
|
|
return s, nil
|
|
}
|
|
|
|
func login(username string) (*lsf.Session, error) {
|
|
password, err := readPassword()
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "could not login")
|
|
}
|
|
s, err := lsf.Login(username, password)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
sessionPath := path.Join(sessionCache, username)
|
|
err = ioutil.WriteFile(sessionPath, []byte(s.SID), 0666)
|
|
if err != nil {
|
|
log.Println(errors.Wrap(err, "could not cache session id"))
|
|
}
|
|
return s, nil
|
|
}
|