2018-01-06 17:53:12 +00:00
|
|
|
package filesystem
|
2016-12-25 20:34:02 +00:00
|
|
|
|
|
|
|
import (
|
2017-10-15 17:24:40 +00:00
|
|
|
"bytes"
|
2018-05-06 07:15:57 +00:00
|
|
|
"encoding/json"
|
|
|
|
"encoding/pem"
|
2017-09-25 16:13:56 +00:00
|
|
|
"io/ioutil"
|
|
|
|
|
2016-12-25 20:34:02 +00:00
|
|
|
"github.com/portainer/portainer"
|
2018-12-09 03:49:27 +00:00
|
|
|
"github.com/portainer/portainer/archive"
|
2016-12-25 20:34:02 +00:00
|
|
|
|
|
|
|
"io"
|
|
|
|
"os"
|
|
|
|
"path"
|
|
|
|
)
|
|
|
|
|
|
|
|
const (
|
|
|
|
// TLSStorePath represents the subfolder where TLS files are stored in the file store folder.
|
|
|
|
TLSStorePath = "tls"
|
2017-08-10 08:35:23 +00:00
|
|
|
// LDAPStorePath represents the subfolder where LDAP TLS files are stored in the TLSStorePath.
|
|
|
|
LDAPStorePath = "ldap"
|
2016-12-25 20:34:02 +00:00
|
|
|
// TLSCACertFile represents the name on disk for a TLS CA file.
|
|
|
|
TLSCACertFile = "ca.pem"
|
|
|
|
// TLSCertFile represents the name on disk for a TLS certificate file.
|
|
|
|
TLSCertFile = "cert.pem"
|
|
|
|
// TLSKeyFile represents the name on disk for a TLS key file.
|
|
|
|
TLSKeyFile = "key.pem"
|
2017-10-15 17:24:40 +00:00
|
|
|
// ComposeStorePath represents the subfolder where compose files are stored in the file store folder.
|
|
|
|
ComposeStorePath = "compose"
|
|
|
|
// ComposeFileDefaultName represents the default name of a compose file.
|
|
|
|
ComposeFileDefaultName = "docker-compose.yml"
|
2018-05-06 07:15:57 +00:00
|
|
|
// PrivateKeyFile represents the name on disk of the file containing the private key.
|
|
|
|
PrivateKeyFile = "portainer.key"
|
|
|
|
// PublicKeyFile represents the name on disk of the file containing the public key.
|
|
|
|
PublicKeyFile = "portainer.pub"
|
2018-12-09 03:49:27 +00:00
|
|
|
// BinaryStorePath represents the subfolder where binaries are stored in the file store folder.
|
|
|
|
BinaryStorePath = "bin"
|
2018-11-05 20:58:15 +00:00
|
|
|
// ScheduleStorePath represents the subfolder where schedule files are stored.
|
|
|
|
ScheduleStorePath = "schedules"
|
2018-12-09 03:49:27 +00:00
|
|
|
// ExtensionRegistryManagementStorePath represents the subfolder where files related to the
|
|
|
|
// registry management extension are stored.
|
|
|
|
ExtensionRegistryManagementStorePath = "extensions"
|
2016-12-25 20:34:02 +00:00
|
|
|
)
|
|
|
|
|
2017-01-02 19:32:53 +00:00
|
|
|
// Service represents a service for managing files and directories.
|
2016-12-25 20:34:02 +00:00
|
|
|
type Service struct {
|
2017-01-02 19:32:53 +00:00
|
|
|
dataStorePath string
|
2016-12-25 20:34:02 +00:00
|
|
|
fileStorePath string
|
|
|
|
}
|
|
|
|
|
2017-01-02 19:32:53 +00:00
|
|
|
// NewService initializes a new service. It creates a data directory and a directory to store files
|
|
|
|
// inside this directory if they don't exist.
|
|
|
|
func NewService(dataStorePath, fileStorePath string) (*Service, error) {
|
2016-12-25 20:34:02 +00:00
|
|
|
service := &Service{
|
2017-01-02 19:32:53 +00:00
|
|
|
dataStorePath: dataStorePath,
|
|
|
|
fileStorePath: path.Join(dataStorePath, fileStorePath),
|
2016-12-25 20:34:02 +00:00
|
|
|
}
|
|
|
|
|
2018-03-13 23:47:21 +00:00
|
|
|
err := os.MkdirAll(dataStorePath, 0755)
|
2016-12-25 20:34:02 +00:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2018-03-13 23:47:21 +00:00
|
|
|
err = service.createDirectoryInStore(TLSStorePath)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
err = service.createDirectoryInStore(ComposeStorePath)
|
2017-10-15 17:24:40 +00:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2018-12-09 03:49:27 +00:00
|
|
|
err = service.createDirectoryInStore(BinaryStorePath)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2016-12-25 20:34:02 +00:00
|
|
|
return service, nil
|
|
|
|
}
|
|
|
|
|
2018-12-09 03:49:27 +00:00
|
|
|
// GetBinaryFolder returns the full path to the binary store on the filesystem
|
|
|
|
func (service *Service) GetBinaryFolder() string {
|
|
|
|
return path.Join(service.fileStorePath, BinaryStorePath)
|
|
|
|
}
|
|
|
|
|
|
|
|
// ExtractExtensionArchive extracts the content of an extension archive
|
|
|
|
// specified as raw data into the binary store on the filesystem
|
|
|
|
func (service *Service) ExtractExtensionArchive(data []byte) error {
|
|
|
|
err := archive.UnzipArchive(data, path.Join(service.fileStorePath, BinaryStorePath))
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-10-15 17:24:40 +00:00
|
|
|
// RemoveDirectory removes a directory on the filesystem.
|
|
|
|
func (service *Service) RemoveDirectory(directoryPath string) error {
|
|
|
|
return os.RemoveAll(directoryPath)
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetStackProjectPath returns the absolute path on the FS for a stack based
|
|
|
|
// on its identifier.
|
|
|
|
func (service *Service) GetStackProjectPath(stackIdentifier string) string {
|
|
|
|
return path.Join(service.fileStorePath, ComposeStorePath, stackIdentifier)
|
|
|
|
}
|
|
|
|
|
2018-06-11 13:13:19 +00:00
|
|
|
// StoreStackFileFromBytes creates a subfolder in the ComposeStorePath and stores a new file from bytes.
|
2017-10-15 17:24:40 +00:00
|
|
|
// It returns the path to the folder where the file is stored.
|
2018-06-11 13:13:19 +00:00
|
|
|
func (service *Service) StoreStackFileFromBytes(stackIdentifier, fileName string, data []byte) (string, error) {
|
2017-10-15 17:24:40 +00:00
|
|
|
stackStorePath := path.Join(ComposeStorePath, stackIdentifier)
|
2018-03-13 23:47:21 +00:00
|
|
|
err := service.createDirectoryInStore(stackStorePath)
|
2017-10-15 17:24:40 +00:00
|
|
|
if err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
|
2018-03-13 11:35:12 +00:00
|
|
|
composeFilePath := path.Join(stackStorePath, fileName)
|
2017-10-15 17:24:40 +00:00
|
|
|
r := bytes.NewReader(data)
|
|
|
|
|
|
|
|
err = service.createFileInStore(composeFilePath, r)
|
|
|
|
if err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
|
|
|
|
return path.Join(service.fileStorePath, stackStorePath), nil
|
|
|
|
}
|
|
|
|
|
2018-12-09 03:49:27 +00:00
|
|
|
// StoreRegistryManagementFileFromBytes creates a subfolder in the
|
|
|
|
// ExtensionRegistryManagementStorePath and stores a new file from bytes.
|
|
|
|
// It returns the path to the folder where the file is stored.
|
|
|
|
func (service *Service) StoreRegistryManagementFileFromBytes(folder, fileName string, data []byte) (string, error) {
|
|
|
|
extensionStorePath := path.Join(ExtensionRegistryManagementStorePath, folder)
|
|
|
|
err := service.createDirectoryInStore(extensionStorePath)
|
|
|
|
if err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
|
|
|
|
file := path.Join(extensionStorePath, fileName)
|
|
|
|
r := bytes.NewReader(data)
|
|
|
|
|
|
|
|
err = service.createFileInStore(file, r)
|
|
|
|
if err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
|
|
|
|
return path.Join(service.fileStorePath, file), nil
|
|
|
|
}
|
|
|
|
|
2018-06-11 13:13:19 +00:00
|
|
|
// StoreTLSFileFromBytes creates a folder in the TLSStorePath and stores a new file from bytes.
|
|
|
|
// It returns the path to the newly created file.
|
|
|
|
func (service *Service) StoreTLSFileFromBytes(folder string, fileType portainer.TLSFileType, data []byte) (string, error) {
|
2017-08-10 08:35:23 +00:00
|
|
|
storePath := path.Join(TLSStorePath, folder)
|
2018-03-13 23:47:21 +00:00
|
|
|
err := service.createDirectoryInStore(storePath)
|
2016-12-25 20:34:02 +00:00
|
|
|
if err != nil {
|
2018-06-11 13:13:19 +00:00
|
|
|
return "", err
|
2016-12-25 20:34:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
var fileName string
|
|
|
|
switch fileType {
|
|
|
|
case portainer.TLSFileCA:
|
|
|
|
fileName = TLSCACertFile
|
|
|
|
case portainer.TLSFileCert:
|
|
|
|
fileName = TLSCertFile
|
|
|
|
case portainer.TLSFileKey:
|
|
|
|
fileName = TLSKeyFile
|
|
|
|
default:
|
2018-06-11 13:13:19 +00:00
|
|
|
return "", portainer.ErrUndefinedTLSFileType
|
2016-12-25 20:34:02 +00:00
|
|
|
}
|
|
|
|
|
2017-08-10 08:35:23 +00:00
|
|
|
tlsFilePath := path.Join(storePath, fileName)
|
2018-06-11 13:13:19 +00:00
|
|
|
r := bytes.NewReader(data)
|
2016-12-25 20:34:02 +00:00
|
|
|
err = service.createFileInStore(tlsFilePath, r)
|
|
|
|
if err != nil {
|
2018-06-11 13:13:19 +00:00
|
|
|
return "", err
|
2016-12-25 20:34:02 +00:00
|
|
|
}
|
2018-06-11 13:13:19 +00:00
|
|
|
return path.Join(service.fileStorePath, tlsFilePath), nil
|
2016-12-25 20:34:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// GetPathForTLSFile returns the absolute path to a specific TLS file for an endpoint.
|
2017-08-10 08:35:23 +00:00
|
|
|
func (service *Service) GetPathForTLSFile(folder string, fileType portainer.TLSFileType) (string, error) {
|
2016-12-25 20:34:02 +00:00
|
|
|
var fileName string
|
|
|
|
switch fileType {
|
|
|
|
case portainer.TLSFileCA:
|
|
|
|
fileName = TLSCACertFile
|
|
|
|
case portainer.TLSFileCert:
|
|
|
|
fileName = TLSCertFile
|
|
|
|
case portainer.TLSFileKey:
|
|
|
|
fileName = TLSKeyFile
|
|
|
|
default:
|
|
|
|
return "", portainer.ErrUndefinedTLSFileType
|
|
|
|
}
|
2017-08-10 08:35:23 +00:00
|
|
|
return path.Join(service.fileStorePath, TLSStorePath, folder, fileName), nil
|
2016-12-25 20:34:02 +00:00
|
|
|
}
|
|
|
|
|
2017-09-14 06:08:37 +00:00
|
|
|
// DeleteTLSFiles deletes a folder in the TLS store path.
|
2017-08-10 08:35:23 +00:00
|
|
|
func (service *Service) DeleteTLSFiles(folder string) error {
|
|
|
|
storePath := path.Join(service.fileStorePath, TLSStorePath, folder)
|
|
|
|
err := os.RemoveAll(storePath)
|
2016-12-25 20:34:02 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-09-14 06:08:37 +00:00
|
|
|
// DeleteTLSFile deletes a specific TLS file from a folder.
|
|
|
|
func (service *Service) DeleteTLSFile(folder string, fileType portainer.TLSFileType) error {
|
|
|
|
var fileName string
|
|
|
|
switch fileType {
|
|
|
|
case portainer.TLSFileCA:
|
|
|
|
fileName = TLSCACertFile
|
|
|
|
case portainer.TLSFileCert:
|
|
|
|
fileName = TLSCertFile
|
|
|
|
case portainer.TLSFileKey:
|
|
|
|
fileName = TLSKeyFile
|
|
|
|
default:
|
|
|
|
return portainer.ErrUndefinedTLSFileType
|
|
|
|
}
|
|
|
|
|
|
|
|
filePath := path.Join(service.fileStorePath, TLSStorePath, folder, fileName)
|
|
|
|
|
|
|
|
err := os.Remove(filePath)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2018-07-03 18:31:02 +00:00
|
|
|
// GetFileContent returns the content of a file as bytes.
|
|
|
|
func (service *Service) GetFileContent(filePath string) ([]byte, error) {
|
2017-10-15 17:24:40 +00:00
|
|
|
content, err := ioutil.ReadFile(filePath)
|
|
|
|
if err != nil {
|
2018-07-03 18:31:02 +00:00
|
|
|
return nil, err
|
2017-10-15 17:24:40 +00:00
|
|
|
}
|
|
|
|
|
2018-07-03 18:31:02 +00:00
|
|
|
return content, nil
|
2017-10-15 17:24:40 +00:00
|
|
|
}
|
|
|
|
|
2018-06-18 10:07:56 +00:00
|
|
|
// Rename renames a file or directory
|
|
|
|
func (service *Service) Rename(oldPath, newPath string) error {
|
|
|
|
return os.Rename(oldPath, newPath)
|
|
|
|
}
|
|
|
|
|
2018-05-06 07:15:57 +00:00
|
|
|
// WriteJSONToFile writes JSON to the specified file.
|
|
|
|
func (service *Service) WriteJSONToFile(path string, content interface{}) error {
|
|
|
|
jsonContent, err := json.Marshal(content)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
return ioutil.WriteFile(path, jsonContent, 0644)
|
|
|
|
}
|
|
|
|
|
2018-06-19 11:15:10 +00:00
|
|
|
// FileExists checks for the existence of the specified file.
|
|
|
|
func (service *Service) FileExists(filePath string) (bool, error) {
|
|
|
|
if _, err := os.Stat(filePath); err != nil {
|
|
|
|
if os.IsNotExist(err) {
|
|
|
|
return false, nil
|
|
|
|
}
|
|
|
|
return false, err
|
|
|
|
}
|
|
|
|
return true, nil
|
|
|
|
}
|
|
|
|
|
2018-05-06 07:15:57 +00:00
|
|
|
// KeyPairFilesExist checks for the existence of the key files.
|
|
|
|
func (service *Service) KeyPairFilesExist() (bool, error) {
|
|
|
|
privateKeyPath := path.Join(service.dataStorePath, PrivateKeyFile)
|
2018-06-19 11:15:10 +00:00
|
|
|
exists, err := service.FileExists(privateKeyPath)
|
2018-05-06 07:15:57 +00:00
|
|
|
if err != nil {
|
|
|
|
return false, err
|
|
|
|
}
|
|
|
|
if !exists {
|
|
|
|
return false, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
publicKeyPath := path.Join(service.dataStorePath, PublicKeyFile)
|
2018-06-19 11:15:10 +00:00
|
|
|
exists, err = service.FileExists(publicKeyPath)
|
2018-05-06 07:15:57 +00:00
|
|
|
if err != nil {
|
|
|
|
return false, err
|
|
|
|
}
|
|
|
|
if !exists {
|
|
|
|
return false, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
return true, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// StoreKeyPair store the specified keys content as PEM files on disk.
|
|
|
|
func (service *Service) StoreKeyPair(private, public []byte, privatePEMHeader, publicPEMHeader string) error {
|
|
|
|
err := service.createPEMFileInStore(private, privatePEMHeader, PrivateKeyFile)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
err = service.createPEMFileInStore(public, publicPEMHeader, PublicKeyFile)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// LoadKeyPair retrieve the content of both key files on disk.
|
|
|
|
func (service *Service) LoadKeyPair() ([]byte, []byte, error) {
|
|
|
|
privateKey, err := service.getContentFromPEMFile(PrivateKeyFile)
|
|
|
|
if err != nil {
|
|
|
|
return nil, nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
publicKey, err := service.getContentFromPEMFile(PublicKeyFile)
|
|
|
|
if err != nil {
|
|
|
|
return nil, nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
return privateKey, publicKey, nil
|
|
|
|
}
|
|
|
|
|
2018-03-13 23:47:21 +00:00
|
|
|
// createDirectoryInStore creates a new directory in the file store
|
|
|
|
func (service *Service) createDirectoryInStore(name string) error {
|
2016-12-25 20:34:02 +00:00
|
|
|
path := path.Join(service.fileStorePath, name)
|
2018-03-13 23:47:21 +00:00
|
|
|
return os.MkdirAll(path, 0700)
|
2016-12-25 20:34:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// createFile creates a new file in the file store with the content from r.
|
|
|
|
func (service *Service) createFileInStore(filePath string, r io.Reader) error {
|
|
|
|
path := path.Join(service.fileStorePath, filePath)
|
2017-10-15 17:24:40 +00:00
|
|
|
|
2016-12-25 20:34:02 +00:00
|
|
|
out, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
defer out.Close()
|
2017-10-15 17:24:40 +00:00
|
|
|
|
2016-12-25 20:34:02 +00:00
|
|
|
_, err = io.Copy(out, r)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2017-09-25 16:13:56 +00:00
|
|
|
|
2017-10-15 17:24:40 +00:00
|
|
|
return nil
|
2017-09-25 16:13:56 +00:00
|
|
|
}
|
2018-05-06 07:15:57 +00:00
|
|
|
|
|
|
|
func (service *Service) createPEMFileInStore(content []byte, fileType, filePath string) error {
|
|
|
|
path := path.Join(service.fileStorePath, filePath)
|
|
|
|
block := &pem.Block{Type: fileType, Bytes: content}
|
|
|
|
|
|
|
|
out, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
defer out.Close()
|
|
|
|
|
|
|
|
err = pem.Encode(out, block)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (service *Service) getContentFromPEMFile(filePath string) ([]byte, error) {
|
|
|
|
path := path.Join(service.fileStorePath, filePath)
|
|
|
|
|
|
|
|
fileContent, err := ioutil.ReadFile(path)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
block, _ := pem.Decode(fileContent)
|
|
|
|
return block.Bytes, nil
|
|
|
|
}
|
2018-11-05 20:58:15 +00:00
|
|
|
|
2018-11-07 04:19:10 +00:00
|
|
|
// GetScheduleFolder returns the absolute path on the filesystem for a schedule based
|
2018-11-05 20:58:15 +00:00
|
|
|
// on its identifier.
|
2018-11-07 04:19:10 +00:00
|
|
|
func (service *Service) GetScheduleFolder(identifier string) string {
|
|
|
|
return path.Join(service.fileStorePath, ScheduleStorePath, identifier)
|
2018-11-05 20:58:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// StoreScheduledJobFileFromBytes creates a subfolder in the ScheduleStorePath and stores a new file from bytes.
|
|
|
|
// It returns the path to the folder where the file is stored.
|
2018-11-07 04:19:10 +00:00
|
|
|
func (service *Service) StoreScheduledJobFileFromBytes(identifier string, data []byte) (string, error) {
|
2018-11-05 20:58:15 +00:00
|
|
|
scheduleStorePath := path.Join(ScheduleStorePath, identifier)
|
|
|
|
err := service.createDirectoryInStore(scheduleStorePath)
|
|
|
|
if err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
|
|
|
|
filePath := path.Join(scheduleStorePath, createScheduledJobFileName(identifier))
|
|
|
|
r := bytes.NewReader(data)
|
|
|
|
err = service.createFileInStore(filePath, r)
|
|
|
|
if err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
|
|
|
|
return path.Join(service.fileStorePath, filePath), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func createScheduledJobFileName(identifier string) string {
|
|
|
|
return "job_" + identifier + ".sh"
|
|
|
|
}
|