d-bis/Sankofa
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update .gitignore, remove package-lock.json, and enhance Cloudflare and Proxmox adapters

Browse Source 
- Added lock file exclusions for pnpm in .gitignore.
- Removed obsolete package-lock.json from the api and portal directories.
- Enhanced Cloudflare adapter with additional interfaces for zones and tunnels.
- Improved Proxmox adapter error handling and logging for API requests.
- Updated Proxmox VM parameters with validation rules in the API schema.
- Enhanced documentation for Proxmox VM specifications and examples.
This commit is contained in:
defiQUG
2025-12-12 19:29:01 -08:00
parent 9daf1fd378
commit 7cd7022f6e
66 changed files with 5892 additions and 14502 deletions
Download Patch File Download Diff File Expand all files Collapse all files

128
crossplane-provider-proxmox/pkg/proxmox/client.go
View File

@@ -8,6 +8,7 @@ import (
"time"
"github.com/pkg/errors"
"github.com/sankofa/crossplane-provider-proxmox/pkg/utils"
)
// Client represents a Proxmox API client
@@ -224,7 +225,11 @@ func (c *Client) createVM(ctx context.Context, spec VMSpec) (*VM, error) {
if spec.Image != "" {
// Check if image is a template ID (numeric VMID to clone from)
if templateID, err := strconv.Atoi(spec.Image); err == nil {
// Use explicit check: if image is all numeric AND within valid VMID range, treat as template
templateID, parseErr := strconv.Atoi(spec.Image)
// Only treat as template if it's a valid VMID (100-999999999) and no other interpretation
// If image name contains non-numeric chars, it's not a template ID
if parseErr == nil && templateID >= 100 && templateID <= 999999999 {
// Clone from template
cloneConfig := map[string]interface{}{
"newid": vmID,
@@ -248,7 +253,7 @@ func (c *Client) createVM(ctx context.Context, spec VMSpec) (*VM, error) {
if spec.UserData != "" {
cloudInitStorage := spec.Storage
if cloudInitStorage == "" {
cloudInitStorage = "local"
cloudInitStorage = "local-lvm" // Use same default as VM storage
}
vmConfig["ide2"] = fmt.Sprintf("%s:cloudinit", cloudInitStorage)
vmConfig["ciuser"] = "admin"
@@ -297,12 +302,14 @@ func (c *Client) createVM(ctx context.Context, spec VMSpec) (*VM, error) {
diskConfig = fmt.Sprintf("%s,format=qcow2", imageVolid)
}
} else if diskConfig == "" {
// No image found and no disk config set, create blank disk
diskConfig = fmt.Sprintf("%s:%d,format=raw", spec.Storage, parseDisk(spec.Disk))
// No image found and no disk config set - this is an error condition
// VMs without OS images cannot boot, so we should fail rather than create blank disk
return nil, errors.Errorf("image '%s' not found in storage and no disk configuration provided. Cannot create VM without OS image", spec.Image)
}
} else {
// No image specified, create blank disk
diskConfig = fmt.Sprintf("%s:%d,format=raw", spec.Storage, parseDisk(spec.Disk))
// No image specified - this is an error condition
// VMs without OS images cannot boot
return nil, errors.New("image is required - cannot create VM without OS image")
}
// Create VM configuration
@@ -327,10 +334,10 @@ func (c *Client) createVM(ctx context.Context, spec VMSpec) (*VM, error) {
// Add cloud-init configuration if userData is provided
if spec.UserData != "" {
// Determine cloud-init storage (use same storage as VM disk, or default to "local")
// Determine cloud-init storage (use same storage as VM disk, or default to "local-lvm")
cloudInitStorage := spec.Storage
if cloudInitStorage == "" {
cloudInitStorage = "local"
cloudInitStorage = "local-lvm" // Use same default as VM storage for consistency
}
// Proxmox cloud-init drive format: ide2=storage:cloudinit
vmConfig["ide2"] = fmt.Sprintf("%s:cloudinit", cloudInitStorage)
@@ -601,11 +608,13 @@ func (c *Client) createVM(ctx context.Context, spec VMSpec) (*VM, error) {
}
}
// Log warning but don't fail VM creation - cloud-init can be configured later
// However, this should be rare and indicates a configuration issue
// Log cloud-init errors for visibility (but don't fail VM creation)
// Cloud-init can be configured later, but we should be aware of failures
if cloudInitErr != nil {
// Note: In production, you might want to add a status condition here
// For now, we continue - VM is created but cloud-init may not work
// Log the error for visibility - cloud-init configuration failed
// VM is created but cloud-init may not work as expected
// In production, this should be tracked via status conditions
// For now, we log and continue - VM is usable but may need manual cloud-init config
}
}
@@ -643,77 +652,13 @@ func (c *Client) getVMByID(ctx context.Context, node string, vmID int) (*VM, err
}, nil
}
// Helper functions for parsing
// Helper functions for parsing (use shared utils)
func parseMemory(memory string) int {
// Parse memory string like "4Gi", "4096M", "4096" to MB
if len(memory) == 0 {
return 4096 // Default
}
// Remove whitespace
memory = strings.TrimSpace(memory)
// Check for unit suffix
if strings.HasSuffix(memory, "Gi") {
value, err := strconv.ParseFloat(strings.TrimSuffix(memory, "Gi"), 64)
if err == nil {
return int(value * 1024) // Convert GiB to MB
}
} else if strings.HasSuffix(memory, "Mi") || strings.HasSuffix(memory, "M") {
value, err := strconv.ParseFloat(strings.TrimSuffix(strings.TrimSuffix(memory, "Mi"), "M"), 64)
if err == nil {
return int(value)
}
} else if strings.HasSuffix(memory, "Ki") || strings.HasSuffix(memory, "K") {
value, err := strconv.ParseFloat(strings.TrimSuffix(strings.TrimSuffix(memory, "Ki"), "K"), 64)
if err == nil {
return int(value / 1024) // Convert KiB to MB
}
}
// Try parsing as number (assume MB)
value, err := strconv.Atoi(memory)
if err == nil {
return value
}
return 4096 // Default if parsing fails
return utils.ParseMemoryToMB(memory)
}
func parseDisk(disk string) int {
// Parse disk string like "50Gi", "50G", "50" to GB
if len(disk) == 0 {
return 50 // Default
}
// Remove whitespace
disk = strings.TrimSpace(disk)
// Check for unit suffix
if strings.HasSuffix(disk, "Gi") || strings.HasSuffix(disk, "G") {
value, err := strconv.ParseFloat(strings.TrimSuffix(strings.TrimSuffix(disk, "Gi"), "G"), 64)
if err == nil {
return int(value)
}
} else if strings.HasSuffix(disk, "Ti") || strings.HasSuffix(disk, "T") {
value, err := strconv.ParseFloat(strings.TrimSuffix(strings.TrimSuffix(disk, "Ti"), "T"), 64)
if err == nil {
return int(value * 1024) // Convert TiB to GB
}
} else if strings.HasSuffix(disk, "Mi") || strings.HasSuffix(disk, "M") {
value, err := strconv.ParseFloat(strings.TrimSuffix(strings.TrimSuffix(disk, "Mi"), "M"), 64)
if err == nil {
return int(value / 1024) // Convert MiB to GB
}
}
// Try parsing as number (assume GB)
value, err := strconv.Atoi(disk)
if err == nil {
return value
}
return 50 // Default if parsing fails
return utils.ParseDiskToGB(disk)
}
// UpdateVM updates a virtual machine
@@ -1134,26 +1079,31 @@ func (c *Client) GetPVEVersion(ctx context.Context) (string, error) {
// SupportsImportDisk checks if the Proxmox version supports the importdisk API
// The importdisk API was added in Proxmox VE 6.0, but some versions may not have it
// This is a best-effort check - actual support is verified at API call time
func (c *Client) SupportsImportDisk(ctx context.Context) (bool, error) {
// Check the version string to determine if importdisk might be available
version, err := c.GetPVEVersion(ctx)
if err != nil {
// If we can't get version, assume it's not supported to be safe
// We'll still try at call time and handle 501 errors gracefully
return false, nil
}
// Parse version: format is usually "pve-manager/X.Y.Z/..."
// importdisk should be available in PVE 6.0+, but some builds may not have it
// For safety, we'll check by attempting to use it and catching 501 errors
// This function returns true if version looks compatible, but actual check happens at use time
if strings.Contains(version, "pve-manager/6.") ||
strings.Contains(version, "pve-manager/7.") ||
strings.Contains(version, "pve-manager/8.") ||
strings.Contains(version, "pve-manager/9.") {
// Version looks compatible, but we'll verify at actual use time
// This is a version-based heuristic - actual support verified via API call
// We return true for versions that likely support it, false otherwise
// The actual API call will handle 501 (not implemented) errors gracefully
versionLower := strings.ToLower(version)
if strings.Contains(versionLower, "pve-manager/6.") ||
strings.Contains(versionLower, "pve-manager/7.") ||
strings.Contains(versionLower, "pve-manager/8.") ||
strings.Contains(versionLower, "pve-manager/9.") {
// Version looks compatible - actual support verified at API call time
return true, nil
}
// Version doesn't match known compatible versions
return false, nil
}
@@ -1218,13 +1168,15 @@ func (c *Client) ListVMs(ctx context.Context, node string, tenantID ...string) (
// If tenant filtering is requested, check VM tags
if filterTenantID != "" {
// Check if VM has tenant tag matching the filter
if vm.Tags == "" || !strings.Contains(vm.Tags, fmt.Sprintf("tenant:%s", filterTenantID)) {
// Note: We use tenant_{id} format (underscore) to match what we write
tenantTag := fmt.Sprintf("tenant_%s", filterTenantID)
if vm.Tags == "" || !strings.Contains(vm.Tags, tenantTag) {
// Try to get VM config to check tags if not in list
var config struct {
Tags string `json:"tags"`
}
if err := c.httpClient.Get(ctx, fmt.Sprintf("/nodes/%s/qemu/%d/config", node, vm.Vmid), &config); err == nil {
if config.Tags == "" || !strings.Contains(config.Tags, fmt.Sprintf("tenant:%s", filterTenantID)) {
if config.Tags == "" || !strings.Contains(config.Tags, tenantTag) {
continue // Skip this VM - doesn't belong to tenant
}
} else {