@zerops/zcli 1.0.0 → 8.0.1

package/src/service/certReader/handler.go

@@ -1,97 +0,0 @@
-package certReader
-
-import (
-	"crypto/x509"
-	"encoding/asn1"
-	"encoding/base64"
-	"encoding/pem"
-	"errors"
-	"strconv"
-	"strings"
-)
-
-var userIdType = asn1.ObjectIdentifier([]int{1, 2, 3, 1})
-
-type Config struct {
-	Token string
-}
-
-type Handler struct {
-	config Config
-
-	CaData, CertData, KeyData []byte
-
-	UserId string
-}
-
-func New(config Config) (h *Handler, err error) {
-
-	h = &Handler{
-		config: config,
-	}
-
-	tokens := strings.Split(config.Token, ";")
-	if len(tokens) != 3 {
-		return h, errors.New("invalid credentials, try `login` command")
-	}
-
-	if h.CaData, err = readData(tokens[0]); err != nil {
-		return
-	}
-	if h.KeyData, err = readData(tokens[1]); err != nil {
-		return
-	}
-	if h.CertData, err = readData(tokens[2]); err != nil {
-		return
-	}
-
-	roots := x509.NewCertPool()
-	ok := roots.AppendCertsFromPEM(h.CertData)
-	if !ok {
-		return nil, errors.New("failed to parse root certificate")
-	}
-
-	block, _ := pem.Decode(h.CertData)
-	if block == nil {
-		return nil, errors.New("failed to parse certificate PEM")
-	}
-	cert, err := x509.ParseCertificate(block.Bytes)
-	if err != nil {
-		return nil, errors.New("failed to parse certificate: " + err.Error())
-	}
-
-	h.UserId, err = func(cert *x509.Certificate) (string, error) {
-		for _, name := range cert.Subject.Names {
-			switch {
-			case name.Type.Equal(userIdType):
-				return name.Value.(string), nil
-			}
-		}
-		return "", errors.New("bad certificate, try contact support")
-	}(cert)
-	if err != nil {
-		return
-	}
-
-	return
-}
-
-func readData(value string) (data []byte, err error) {
-	valueB, err := base64.StdEncoding.DecodeString(value)
-	if err != nil {
-		return nil, err
-	}
-	value = string(valueB)
-
-	if strings.Contains(value, `\n`) && !strings.HasPrefix(value, `"`) {
-		value = `"` + value + `"`
-	}
-	if !strings.HasPrefix(value, `"`) {
-		return []byte(value), err
-	}
-	valueCaUnquote, err := strconv.Unquote(value)
-	if err != nil {
-		return nil, err
-	}
-	return []byte(valueCaUnquote), nil
-}

package/src/service/httpClient/handler.go

@@ -1,90 +0,0 @@
-package httpClient
-
-import (
-	"bytes"
-	"io/ioutil"
-	"net/http"
-	"time"
-)
-
-type Config struct {
-	HttpTimeout time.Duration
-}
-
-type Response struct {
-	StatusCode int
-	Body       []byte
-}
-
-type Handler struct {
-	config Config
-}
-
-func New(config Config) *Handler {
-	return &Handler{
-		config: config,
-	}
-}
-
-type Option func(cfg *optionConfig)
-
-func ContentType(contentType string) Option {
-	return func(cfg *optionConfig) {
-		cfg.headers["Content-Type"] = contentType
-	}
-}
-
-func BearerAuthorization(token string) Option {
-	return func(cfg *optionConfig) {
-		cfg.headers["Authorization"] = "Bearer " + token
-	}
-}
-
-type optionConfig struct {
-	headers map[string]string
-}
-
-func (h *Handler) Put(url string, data []byte, options ...Option) (Response, error) {
-	return h.do("PUT", url, data, options...)
-}
-
-func (h *Handler) Post(url string, data []byte, options ...Option) (Response, error) {
-	return h.do("POST", url, data, options...)
-}
-
-func (h *Handler) do(method string, url string, data []byte, options ...Option) (Response, error) {
-	cfg := &optionConfig{
-		headers: map[string]string{
-			"Content-Type": "application/json",
-		},
-	}
-	for _, o := range options {
-		o(cfg)
-	}
-
-	client := &http.Client{Timeout: h.config.HttpTimeout}
-	req, err := http.NewRequest(method, url, bytes.NewReader(data))
-	if err != nil {
-		return Response{}, err
-	}
-
-	for key, value := range cfg.headers {
-		req.Header.Add(key, value)
-	}
-
-	resp, err := client.Do(req)
-	if err != nil {
-		return Response{}, err
-	}
-	defer resp.Body.Close()
-
-	bodyBytes, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return Response{}, err
-	}
-
-	return Response{
-		StatusCode: resp.StatusCode,
-		Body:       bodyBytes,
-	}, nil
-}

package/src/service/logger/handler.go

@@ -1,32 +0,0 @@
-package logger
-
-import "fmt"
-
-type Config struct {
-}
-
-type Handler struct {
-	config Config
-}
-
-func New(config Config) *Handler {
-	return &Handler{
-		config: config,
-	}
-}
-
-func (h *Handler) Info(a ...interface{}) {
-	fmt.Println(a...)
-}
-
-func (h *Handler) Warning(a ...interface{}) {
-	fmt.Println(a...)
-}
-
-func (h *Handler) Error(a ...interface{}) {
-	fmt.Println(a...)
-}
-
-func (h *Handler) Debug(a ...interface{}) {
-	fmt.Println(a...)
-}

package/src/service/logger/interface.go

@@ -1,8 +0,0 @@
-package logger
-
-type Logger interface {
-	Info(a ...interface{})
-	Warning(a ...interface{})
-	Error(a ...interface{})
-	Debug(a ...interface{})
-}

package/src/service/params/handler.go

@@ -1,111 +0,0 @@
-package params
-
-import (
-	"os"
-
-	"github.com/zerops-io/zcli/src/service/storage"
-
-	"github.com/spf13/cobra"
-	"github.com/spf13/viper"
-	loggerPackage "github.com/zerops-io/zcli/src/service/logger"
-)
-
-type Handler struct {
-	logger  loggerPackage.Logger
-	storage *storage.Handler
-
-	params map[string]interface{}
-	viper  *viper.Viper
-}
-
-func New(
-	logger loggerPackage.Logger,
-	storage *storage.Handler,
-) *Handler {
-	return &Handler{
-		logger:  logger,
-		storage: storage,
-
-		params: make(map[string]interface{}),
-		viper:  viper.New(),
-	}
-}
-
-type Option func(cfg *optionConfig)
-
-func Persistent() Option {
-	return func(cfg *optionConfig) {
-		cfg.persistent = true
-	}
-}
-
-func FromTempData(f func(data *storage.Data) interface{}) Option {
-	return func(cfg *optionConfig) {
-		cfg.loadFromTempData = f
-	}
-}
-
-type optionConfig struct {
-	persistent       bool
-	loadFromTempData func(data *storage.Data) interface{}
-}
-
-func (h *Handler) RegisterString(cmd *cobra.Command, name, defaultValue, description string, options ...Option) {
-	var paramValue string
-
-	cfg := &optionConfig{}
-	for _, o := range options {
-		o(cfg)
-	}
-
-	if cfg.persistent {
-		cmd.PersistentFlags().StringVar(&paramValue, name, "", description)
-		h.viper.BindPFlags(cmd.PersistentFlags())
-	} else {
-		cmd.Flags().StringVar(&paramValue, name, "", description)
-	}
-
-	h.params[name] = func() string {
-		if paramValue != "" {
-			return paramValue
-		}
-		if cfg.loadFromTempData != nil {
-			value := cfg.loadFromTempData(h.storage.Data)
-			if v, ok := value.(string); ok {
-				return v
-			}
-		}
-		if h.viper.GetString(name) != "" {
-			return h.viper.GetString(name)
-		}
-
-		return defaultValue
-	}
-}
-
-func (h *Handler) GetString(name string) string {
-	if param, exists := h.params[name]; exists {
-		if v, ok := param.(func() string); ok {
-			return v()
-		}
-		return ""
-	}
-	return ""
-}
-
-func (h *Handler) InitViper() error {
-
-	path, err := os.Getwd()
-	if err != nil {
-		return err
-	}
-	h.viper.AddConfigPath(path)
-	h.viper.SetConfigName("zcli.config")
-	h.viper.AutomaticEnv()
-
-	if err := h.viper.ReadInConfig(); err == nil {
-		h.logger.Info("Using config file:", h.viper.ConfigFileUsed())
-	}
-
-	return nil
-}

package/src/service/storage/handler.go

@@ -1,71 +0,0 @@
-package storage
-
-import (
-	"encoding/json"
-	"io/ioutil"
-	"os"
-)
-
-type Config struct {
-	FilePath string
-}
-
-type Handler struct {
-	config Config
-
-	Data *Data
-}
-
-type Data struct {
-	ProjectId string
-	ServerIp  string
-	Token     string
-}
-
-func New(config Config) (*Handler, error) {
-
-	h := &Handler{
-		config: config,
-		Data:   &Data{},
-	}
-
-	if fileExists(config.FilePath) {
-		f, err := os.Open(config.FilePath)
-		if err != nil {
-			return nil, err
-		}
-		defer f.Close()
-
-		bytes, err := ioutil.ReadAll(f)
-		if err != nil {
-			return nil, err
-		}
-
-		err = json.Unmarshal(bytes, &h.Data)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	return h, nil
-}
-
-func (h *Handler) Save() error {
-	data, err := json.Marshal(h.Data)
-	if err != nil {
-		return err
-	}
-	err = ioutil.WriteFile(h.config.FilePath, data, 0644)
-	if err != nil {
-		return err
-	}
-	return err
-}
-
-func fileExists(filename string) bool {
-	info, err := os.Stat(filename)
-	if os.IsNotExist(err) {
-		return false
-	}
-	return !info.IsDir()
-}

package/src/service/sudoers/handler.go

@@ -1,49 +0,0 @@
-package sudoers
-
-import (
-	"errors"
-	"os/exec"
-
-	"github.com/zerops-io/zcli/src/helpers/cmdRunner"
-)
-
-var IpAlreadySetErr = cmdRunner.IpAlreadySetErr
-var CannotFindDeviceErr = cmdRunner.CannotFindDeviceErr
-var OperationNotPermitted = cmdRunner.OperationNotPermitted
-
-type Config struct {
-}
-
-type Handler struct {
-	config Config
-}
-
-func New(config Config) *Handler {
-	return &Handler{
-		config: config,
-	}
-}
-
-// command with installation if operation is not permitted
-func (h *Handler) RunCommand(cmd *exec.Cmd) ([]byte, error) {
-
-	sudoCmd := exec.Command("sudo", cmd.Args...)
-	sudoCmd.Env = cmd.Env
-	sudoCmd.Stdin = cmd.Stdin
-	sudoCmd.Stderr = cmd.Stderr
-	sudoCmd.Stdout = cmd.Stdout
-	sudoCmd.Dir = cmd.Dir
-
-	output, err := cmdRunner.Run(sudoCmd)
-	if err != nil {
-		if errors.Is(err, OperationNotPermitted) {
-
-			newCmd := exec.Command("sudo", cmd.Args...)
-
-			output, err = cmdRunner.Run(newCmd)
-		}
-	}
-
-	return output, err
-
-}

package/src/service/tlsConfig/handler.go

@@ -1,36 +0,0 @@
-package tlsConfig
-
-import (
-	"crypto/tls"
-	"crypto/x509"
-	"errors"
-
-	"github.com/zerops-io/zcli/src/service/certReader"
-)
-
-func CreateTlsConfig(certReader *certReader.Handler) (tlsConfig *tls.Config, err error) {
-	tlsConfig = &tls.Config{}
-	tlsConfig.InsecureSkipVerify = true
-	tlsConfig.ClientAuth = tls.RequireAndVerifyClientCert
-
-	var crt tls.Certificate
-	crt, err = tls.X509KeyPair(certReader.CertData, certReader.KeyData)
-	if err != nil {
-		return nil, err
-	}
-
-	tlsConfig.Certificates = []tls.Certificate{crt}
-
-	var caCertPool *x509.CertPool
-	caCertPool, err = x509.SystemCertPool()
-	if err != nil {
-		return nil, err
-	}
-	if ok := caCertPool.AppendCertsFromPEM(certReader.CaData); !ok {
-		return nil, errors.New("error append cert from PEM")
-	}
-	tlsConfig.RootCAs = caCertPool
-	tlsConfig.ClientCAs = caCertPool
-
-	return
-}

package/src/service/zipClient/handler.go

@@ -1,144 +0,0 @@
-package zipClient
-
-import (
-	"archive/zip"
-	"errors"
-	"io"
-	"os"
-	"path"
-	"path/filepath"
-	"strings"
-
-	"github.com/zerops-io/zcli/src/service/logger"
-)
-
-type Config struct {
-}
-
-type Handler struct {
-	config Config
-	logger logger.Logger
-}
-
-func New(config Config, logger logger.Logger) *Handler {
-	return &Handler{
-		config: config,
-		logger: logger,
-	}
-}
-
-func (h *Handler) Zip(w io.Writer, workingDir string, sources ...string) error {
-	archive := zip.NewWriter(w)
-	defer archive.Close()
-
-	workingDir, err := filepath.Abs(workingDir)
-	if err != nil {
-		return err
-	}
-
-	h.logger.Info("working directory: " + workingDir)
-
-	for _, source := range sources {
-
-		parts := strings.Split(source, "*")
-		if len(parts) > 2 {
-			return errors.New("only one *(asterisk) is allowed")
-		}
-		if len(parts) == 1 {
-			parts = []string{
-				"", parts[0],
-			}
-		}
-
-		source := path.Join(workingDir, path.Join(parts...))
-		source, err := filepath.Abs(source)
-		if err != nil {
-			return err
-		}
-
-		trimPart := path.Join(workingDir, parts[0])
-
-		fileInfo, err := os.Lstat(source)
-		if err != nil {
-			return err
-		}
-
-		if fileInfo.IsDir() {
-			h.logger.Info("packing directory: " + source)
-		} else {
-			h.logger.Info("packing file: " + source)
-		}
-
-		err = filepath.Walk(source, func(filePath string, info os.FileInfo, err error) error {
-			if err != nil {
-				return err
-			}
-
-			header, err := zip.FileInfoHeader(info)
-			if err != nil {
-				return err
-			}
-
-			header.Name = strings.TrimPrefix(func(filePath string) string {
-				if info.IsDir() {
-					filePath += "/"
-				}
-
-				filePath = strings.TrimPrefix(filePath, trimPart)
-
-				if filePath == parts[0] {
-					return ""
-				}
-				return strings.TrimPrefix(filePath, parts[0])
-
-			}(filePath), "/")
-
-			if header.Name == "" {
-				return nil
-			}
-
-			if !info.IsDir() {
-				header.Method = zip.Deflate
-			}
-
-			writer, err := archive.CreateHeader(header)
-			if err != nil {
-				return err
-			}
-
-			if info.IsDir() {
-				return nil
-			}
-
-			if header.FileInfo().Mode()&os.ModeSymlink != 0 {
-				symlink, err := os.Readlink(filePath)
-				if err != nil {
-					return err
-				}
-
-				_, err = writer.Write([]byte(symlink))
-				if err != nil {
-					return err
-				}
-			} else {
-				file, err := os.Open(filePath)
-				if err != nil {
-					return err
-				}
-				defer file.Close()
-				_, err = io.Copy(writer, file)
-				if err != nil {
-					return err
-				}
-			}
-
-			return nil
-		})
-
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}

package/src/service/zipClient/test/var/www/dir/file2.1.txt

@@ -1 +0,0 @@
-symlink