mirror of
https://github.com/bpg/terraform-provider-proxmox.git
synced 2025-07-01 19:12:59 +00:00
401b39782f
* fix(file): "Permission denied" error when creating a file by a non-root user * fix linter errors
383 lines
10 KiB
Go
383 lines
10 KiB
Go
/*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
|
|
*/
|
|
|
|
package proxmox
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"mime/multipart"
|
|
"net/http"
|
|
"net/url"
|
|
"os"
|
|
"path/filepath"
|
|
"sort"
|
|
|
|
"github.com/hashicorp/terraform-plugin-log/tflog"
|
|
"golang.org/x/crypto/ssh"
|
|
|
|
"github.com/pkg/sftp"
|
|
)
|
|
|
|
// GetDatastore retrieves information about a datastore.
|
|
/*
|
|
Using undocumented API endpoints is not recommended, but sometimes it's the only way to get things done.
|
|
$ pvesh get /storage/local
|
|
┌─────────┬───────────────────────────────────────────┐
|
|
│ key │ value │
|
|
╞═════════╪═══════════════════════════════════════════╡
|
|
│ content │ images,vztmpl,iso,backup,snippets,rootdir │
|
|
├─────────┼───────────────────────────────────────────┤
|
|
│ digest │ 5b65ede80f34631d6039e6922845cfa4abc956be │
|
|
├─────────┼───────────────────────────────────────────┤
|
|
│ path │ /var/lib/vz │
|
|
├─────────┼───────────────────────────────────────────┤
|
|
│ shared │ 0 │
|
|
├─────────┼───────────────────────────────────────────┤
|
|
│ storage │ local │
|
|
├─────────┼───────────────────────────────────────────┤
|
|
│ type │ dir │
|
|
└─────────┴───────────────────────────────────────────┘
|
|
*/
|
|
func (c *VirtualEnvironmentClient) GetDatastore(
|
|
ctx context.Context,
|
|
datastoreID string,
|
|
) (*DatastoreGetResponseData, error) {
|
|
resBody := &DatastoreGetResponseBody{}
|
|
err := c.DoRequest(
|
|
ctx,
|
|
http.MethodGet,
|
|
fmt.Sprintf("storage/%s", url.PathEscape(datastoreID)),
|
|
nil,
|
|
resBody,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return resBody.Data, nil
|
|
}
|
|
|
|
// DeleteDatastoreFile deletes a file in a datastore.
|
|
func (c *VirtualEnvironmentClient) DeleteDatastoreFile(
|
|
ctx context.Context,
|
|
nodeName, datastoreID, volumeID string,
|
|
) error {
|
|
err := c.DoRequest(
|
|
ctx,
|
|
http.MethodDelete,
|
|
fmt.Sprintf(
|
|
"nodes/%s/storage/%s/content/%s",
|
|
url.PathEscape(nodeName),
|
|
url.PathEscape(datastoreID),
|
|
url.PathEscape(volumeID),
|
|
),
|
|
nil,
|
|
nil,
|
|
)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// GetDatastoreStatus gets status information for a given datastore.
|
|
func (c *VirtualEnvironmentClient) GetDatastoreStatus(
|
|
ctx context.Context,
|
|
nodeName, datastoreID string,
|
|
) (*DatastoreGetStatusResponseData, error) {
|
|
resBody := &DatastoreGetStatusResponseBody{}
|
|
err := c.DoRequest(
|
|
ctx,
|
|
http.MethodGet,
|
|
fmt.Sprintf(
|
|
"nodes/%s/storage/%s/status",
|
|
url.PathEscape(nodeName),
|
|
url.PathEscape(datastoreID),
|
|
),
|
|
nil,
|
|
resBody,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if resBody.Data == nil {
|
|
return nil, errors.New("the server did not include a data object in the response")
|
|
}
|
|
|
|
return resBody.Data, nil
|
|
}
|
|
|
|
// ListDatastoreFiles retrieves a list of the files in a datastore.
|
|
func (c *VirtualEnvironmentClient) ListDatastoreFiles(
|
|
ctx context.Context,
|
|
nodeName, datastoreID string,
|
|
) ([]*DatastoreFileListResponseData, error) {
|
|
resBody := &DatastoreFileListResponseBody{}
|
|
err := c.DoRequest(
|
|
ctx,
|
|
http.MethodGet,
|
|
fmt.Sprintf(
|
|
"nodes/%s/storage/%s/content",
|
|
url.PathEscape(nodeName),
|
|
url.PathEscape(datastoreID),
|
|
),
|
|
nil,
|
|
resBody,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if resBody.Data == nil {
|
|
return nil, errors.New("the server did not include a data object in the response")
|
|
}
|
|
|
|
sort.Slice(resBody.Data, func(i, j int) bool {
|
|
return resBody.Data[i].VolumeID < resBody.Data[j].VolumeID
|
|
})
|
|
|
|
return resBody.Data, nil
|
|
}
|
|
|
|
// ListDatastores retrieves a list of nodes.
|
|
func (c *VirtualEnvironmentClient) ListDatastores(
|
|
ctx context.Context,
|
|
nodeName string,
|
|
d *DatastoreListRequestBody,
|
|
) ([]*DatastoreListResponseData, error) {
|
|
resBody := &DatastoreListResponseBody{}
|
|
err := c.DoRequest(
|
|
ctx,
|
|
http.MethodGet,
|
|
fmt.Sprintf("nodes/%s/storage", url.PathEscape(nodeName)),
|
|
d,
|
|
resBody,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if resBody.Data == nil {
|
|
return nil, errors.New("the server did not include a data object in the response")
|
|
}
|
|
|
|
sort.Slice(resBody.Data, func(i, j int) bool {
|
|
return resBody.Data[i].ID < resBody.Data[j].ID
|
|
})
|
|
|
|
return resBody.Data, nil
|
|
}
|
|
|
|
// UploadFileToDatastore uploads a file to a datastore.
|
|
func (c *VirtualEnvironmentClient) UploadFileToDatastore(
|
|
ctx context.Context,
|
|
d *DatastoreUploadRequestBody,
|
|
) (*DatastoreUploadResponseBody, error) {
|
|
switch d.ContentType {
|
|
case "iso", "vztmpl":
|
|
r, w := io.Pipe()
|
|
|
|
defer func(r *io.PipeReader) {
|
|
err := r.Close()
|
|
if err != nil {
|
|
tflog.Error(ctx, "failed to close pipe reader", map[string]interface{}{
|
|
"error": err,
|
|
})
|
|
}
|
|
}(r)
|
|
|
|
m := multipart.NewWriter(w)
|
|
|
|
go func() {
|
|
defer func(w *io.PipeWriter) {
|
|
err := w.Close()
|
|
if err != nil {
|
|
tflog.Error(ctx, "failed to close pipe writer", map[string]interface{}{
|
|
"error": err,
|
|
})
|
|
}
|
|
}(w)
|
|
defer func(m *multipart.Writer) {
|
|
err := m.Close()
|
|
if err != nil {
|
|
tflog.Error(ctx, "failed to close multipart writer", map[string]interface{}{
|
|
"error": err,
|
|
})
|
|
}
|
|
}(m)
|
|
|
|
err := m.WriteField("content", d.ContentType)
|
|
if err != nil {
|
|
tflog.Error(ctx, "failed to write 'content' field", map[string]interface{}{
|
|
"error": err,
|
|
})
|
|
return
|
|
}
|
|
|
|
part, err := m.CreateFormFile("filename", d.FileName)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
_, err = io.Copy(part, d.FileReader)
|
|
|
|
if err != nil {
|
|
return
|
|
}
|
|
}()
|
|
|
|
// We need to store the multipart content in a temporary file to avoid using high amounts of memory.
|
|
// This is necessary due to Proxmox VE not supporting chunked transfers in v6.1 and earlier versions.
|
|
tempMultipartFile, err := os.CreateTemp("", "multipart")
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to create temporary file: %w", err)
|
|
}
|
|
|
|
tempMultipartFileName := tempMultipartFile.Name()
|
|
|
|
_, err = io.Copy(tempMultipartFile, r)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to copy multipart data to temporary file: %w", err)
|
|
}
|
|
|
|
err = tempMultipartFile.Close()
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to close temporary file: %w", err)
|
|
}
|
|
|
|
defer func(name string) {
|
|
err := os.Remove(name)
|
|
if err != nil {
|
|
tflog.Error(ctx, "failed to remove temporary file", map[string]interface{}{
|
|
"error": err,
|
|
})
|
|
}
|
|
}(tempMultipartFileName)
|
|
|
|
// Now that the multipart data is stored in a file, we can go ahead and do a HTTP POST request.
|
|
fileReader, err := os.Open(tempMultipartFileName)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to open temporary file: %w", err)
|
|
}
|
|
|
|
defer func(fileReader *os.File) {
|
|
err := fileReader.Close()
|
|
if err != nil {
|
|
tflog.Error(ctx, "failed to close file reader", map[string]interface{}{
|
|
"error": err,
|
|
})
|
|
}
|
|
}(fileReader)
|
|
|
|
fileInfo, err := fileReader.Stat()
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to get file info: %w", err)
|
|
}
|
|
|
|
fileSize := fileInfo.Size()
|
|
|
|
reqBody := &VirtualEnvironmentMultiPartData{
|
|
Boundary: m.Boundary(),
|
|
Reader: fileReader,
|
|
Size: &fileSize,
|
|
}
|
|
|
|
resBody := &DatastoreUploadResponseBody{}
|
|
err = c.DoRequest(
|
|
ctx,
|
|
http.MethodPost,
|
|
fmt.Sprintf(
|
|
"nodes/%s/storage/%s/upload",
|
|
url.PathEscape(d.NodeName),
|
|
url.PathEscape(d.DatastoreID),
|
|
),
|
|
reqBody,
|
|
resBody,
|
|
)
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return resBody, nil
|
|
default:
|
|
// We need to upload all other files using SFTP due to API limitations.
|
|
// Hopefully, this will not be required in future releases of Proxmox VE.
|
|
sshClient, err := c.OpenNodeShell(ctx, d.NodeName)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
defer func(sshClient *ssh.Client) {
|
|
err := sshClient.Close()
|
|
if err != nil {
|
|
tflog.Error(ctx, "failed to close SSH client", map[string]interface{}{
|
|
"error": err,
|
|
})
|
|
}
|
|
}(sshClient)
|
|
|
|
datastore, err := c.GetDatastore(ctx, d.DatastoreID)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to get datastore: %w", err)
|
|
}
|
|
if datastore.Path == nil || *datastore.Path == "" {
|
|
return nil, errors.New("failed to determine the datastore path")
|
|
}
|
|
|
|
remoteFileDir := *datastore.Path
|
|
if d.ContentType != "" {
|
|
remoteFileDir = filepath.Join(remoteFileDir, d.ContentType)
|
|
}
|
|
|
|
remoteFilePath := filepath.Join(remoteFileDir, d.FileName)
|
|
sftpClient, err := sftp.NewClient(sshClient)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to create SFTP client: %w", err)
|
|
}
|
|
|
|
defer func(sftpClient *sftp.Client) {
|
|
err := sftpClient.Close()
|
|
if err != nil {
|
|
tflog.Error(ctx, "failed to close SFTP client", map[string]interface{}{
|
|
"error": err,
|
|
})
|
|
}
|
|
}(sftpClient)
|
|
|
|
err = sftpClient.MkdirAll(remoteFileDir)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to create directory %s: %w", remoteFileDir, err)
|
|
}
|
|
|
|
remoteFile, err := sftpClient.Create(remoteFilePath)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to create file %s: %w", remoteFilePath, err)
|
|
}
|
|
|
|
defer func(remoteFile *sftp.File) {
|
|
err := remoteFile.Close()
|
|
if err != nil {
|
|
tflog.Error(ctx, "failed to close remote file", map[string]interface{}{
|
|
"error": err,
|
|
})
|
|
}
|
|
}(remoteFile)
|
|
|
|
_, err = remoteFile.ReadFrom(d.FileReader)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to upload file %s: %w", remoteFilePath, err)
|
|
}
|
|
|
|
return &DatastoreUploadResponseBody{}, nil
|
|
}
|
|
}
|