cnsCode to just errorCode

Author: pjohnst5

cns/api.go

@@ -397,7 +397,7 @@ type AssignIBDevicesToPodRequest struct {
 
 // AssignIBDevicesToPodResponse represents the response for assigning InfiniBand devices to a pod
 type AssignIBDevicesToPodResponse struct {
-	Response Response `json:"response"` // Contains cnsCode (int) and message (string)
+	Response Response `json:"response"` // Contains errorCode (int) and message (string)
 }
 
 // GetIBDeviceInfoRequest represents the request to get InfiniBand device information

cns/grpc/proto/server.proto

@@ -56,7 +56,7 @@ message AssignIBDevicesToPodRequest {
 
 // AssignIBDevicesToPodResponse is the response message for assigning InfiniBand devices to a pod.
 message AssignIBDevicesToPodResponse {
-  int32 cnsCode = 1; // CNS response code (0 for success).
+  int32 errorCode = 1; // Error code (0 for success).
   string message = 2; // Response message.
 }
 

cns/grpc/v1alpha/server.pb.go

@@ -0,0 +1,315 @@
+// Copyright 2017 Microsoft. All rights reserved.
+// MIT License
+
+package restserver
+
+import (
+	"fmt"
+	"sync"
+	"time"
+
+	"github.com/Azure/azure-container-networking/cns/logger"
+	"github.com/Azure/azure-container-networking/cns/types"
+)
+
+// IBDeviceState represents the state of an InfiniBand device
+type IBDeviceState int
+
+const (
+	IBDeviceAvailable IBDeviceState = iota
+	IBDeviceAssigned
+	IBDevicePendingRelease
+)
+
+func (s IBDeviceState) String() string {
+	switch s {
+	case IBDeviceAvailable:
+		return "available"
+	case IBDeviceAssigned:
+		return "assigned"
+	case IBDevicePendingRelease:
+		return "pendingrelease"
+	default:
+		return "unknown"
+	}
+}
+
+// IBDeviceInfo contains information about an InfiniBand device
+type IBDeviceInfo struct {
+	DeviceID            string        `json:"deviceID"`
+	MacAddress          string        `json:"macAddress"`
+	State               IBDeviceState `json:"state"`
+	PodID               string        `json:"podID,omitempty"`
+	AssignedAt          time.Time     `json:"assignedAt,omitempty"`
+	LastStateTransition time.Time     `json:"lastStateTransition"`
+	ErrorCode           int           `json:"errorCode"`
+	ErrorMessage        string        `json:"errorMessage,omitempty"`
+	mu                  sync.RWMutex  `json:"-"`
+}
+
+// SetState updates the device state and timestamp
+func (d *IBDeviceInfo) SetState(newState IBDeviceState) {
+	d.mu.Lock()
+	defer d.mu.Unlock()
+	d.State = newState
+	d.LastStateTransition = time.Now()
+}
+
+// GetState returns the current device state
+func (d *IBDeviceInfo) GetState() IBDeviceState {
+	d.mu.RLock()
+	defer d.mu.RUnlock()
+	return d.State
+}
+
+// Assign assigns the device to a pod
+func (d *IBDeviceInfo) Assign(podID string) {
+	d.mu.Lock()
+	defer d.mu.Unlock()
+	d.PodID = podID
+	d.State = IBDeviceAssigned
+	d.AssignedAt = time.Now()
+	d.LastStateTransition = time.Now()
+	d.ErrorCode = 0
+	d.ErrorMessage = ""
+}
+
+// Release releases the device from a pod
+func (d *IBDeviceInfo) Release() {
+	d.mu.Lock()
+	defer d.mu.Unlock()
+	d.PodID = ""
+	d.State = IBDeviceAvailable
+	d.AssignedAt = time.Time{}
+	d.LastStateTransition = time.Now()
+	d.ErrorCode = 0
+	d.ErrorMessage = ""
+}
+
+// SetError sets an error state for the device
+func (d *IBDeviceInfo) SetError(code int, message string) {
+	d.mu.Lock()
+	defer d.mu.Unlock()
+	d.ErrorCode = code
+	d.ErrorMessage = message
+	d.LastStateTransition = time.Now()
+}
+
+// IBDeviceManager manages the state of InfiniBand devices
+type IBDeviceManager struct {
+	devices      map[string]*IBDeviceInfo // deviceID -> device info
+	podDevices   map[string][]string      // podID -> list of deviceIDs
+	devicesByMac map[string]string        // macAddress -> deviceID
+	mu           sync.RWMutex
+}
+
+// NewIBDeviceManager creates a new IB device manager
+func NewIBDeviceManager() *IBDeviceManager {
+	return &IBDeviceManager{
+		devices:      make(map[string]*IBDeviceInfo),
+		podDevices:   make(map[string][]string),
+		devicesByMac: make(map[string]string),
+	}
+}
+
+// RegisterDevice registers a new IB device
+func (m *IBDeviceManager) RegisterDevice(deviceID, macAddress string) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	// Check if device already exists
+	if _, exists := m.devices[deviceID]; exists {
+		logger.Printf("[IBDeviceManager] Device %s already registered", deviceID)
+		return nil
+	}
+
+	// Check if MAC address is already registered
+	if existingDeviceID, exists := m.devicesByMac[macAddress]; exists {
+		logger.Printf("[IBDeviceManager] MAC address %s already registered to device %s", macAddress, existingDeviceID)
+		return nil
+	}
+
+	device := &IBDeviceInfo{
+		DeviceID:            deviceID,
+		MacAddress:          macAddress,
+		State:               IBDeviceAvailable,
+		LastStateTransition: time.Now(),
+		ErrorCode:           0,
+	}
+
+	m.devices[deviceID] = device
+	m.devicesByMac[macAddress] = deviceID
+
+	logger.Printf("[IBDeviceManager] Registered device %s with MAC %s", deviceID, macAddress)
+	return nil
+}
+
+// GetDevice returns device information by device ID
+func (m *IBDeviceManager) GetDevice(deviceID string) (*IBDeviceInfo, bool) {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+
+	device, exists := m.devices[deviceID]
+	if !exists {
+		return nil, false
+	}
+
+	// Return a copy to avoid race conditions
+	deviceCopy := *device
+	return &deviceCopy, true
+}
+
+// GetDeviceByMac returns device information by MAC address
+func (m *IBDeviceManager) GetDeviceByMac(macAddress string) (*IBDeviceInfo, bool) {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+
+	deviceID, exists := m.devicesByMac[macAddress]
+	if !exists {
+		return nil, false
+	}
+
+	device, exists := m.devices[deviceID]
+	if !exists {
+		return nil, false
+	}
+
+	// Return a copy to avoid race conditions
+	deviceCopy := *device
+	return &deviceCopy, true
+}
+
+// AssignDevicesToPod assigns multiple devices to a pod
+func (m *IBDeviceManager) AssignDevicesToPod(podID string, deviceIDs []string) (types.ResponseCode, string) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	// Validate all devices first
+	for _, deviceID := range deviceIDs {
+		device, exists := m.devices[deviceID]
+		if !exists {
+			return types.NotFound, "Device " + deviceID + " not found"
+		}
+
+		if device.GetState() != IBDeviceAvailable {
+			if device.GetState() == IBDeviceAssigned {
+				return types.InvalidRequest, "Device " + deviceID + " is already assigned to pod " + device.PodID
+			}
+			return types.InvalidRequest, "Device " + deviceID + " is not available (state: " + device.GetState().String() + ")"
+		}
+	}
+
+	// Check if pod already has devices assigned
+	if existingDevices, exists := m.podDevices[podID]; exists && len(existingDevices) > 0 {
+		return types.InvalidRequest, "Pod " + podID + " already has devices assigned"
+	}
+
+	// Assign all devices
+	assignedDevices := make([]string, 0, len(deviceIDs))
+	for _, deviceID := range deviceIDs {
+		device := m.devices[deviceID]
+		device.Assign(podID)
+		assignedDevices = append(assignedDevices, deviceID)
+		logger.Printf("[IBDeviceManager] Assigned device %s to pod %s", deviceID, podID)
+	}
+
+	// Update pod device mapping
+	m.podDevices[podID] = assignedDevices
+
+	return types.Success, "Successfully assigned " + fmt.Sprintf("%d", len(deviceIDs)) + " devices to pod " + podID
+}
+
+// ReleaseDevicesFromPod releases all devices assigned to a pod
+func (m *IBDeviceManager) ReleaseDevicesFromPod(podID string) (types.ResponseCode, string) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	deviceIDs, exists := m.podDevices[podID]
+	if !exists || len(deviceIDs) == 0 {
+		return types.NotFound, "No devices assigned to pod " + podID
+	}
+
+	// Release all devices
+	for _, deviceID := range deviceIDs {
+		if device, exists := m.devices[deviceID]; exists {
+			device.Release()
+			logger.Printf("[IBDeviceManager] Released device %s from pod %s", deviceID, podID)
+		}
+	}
+
+	// Remove pod device mapping
+	delete(m.podDevices, podID)
+
+	return types.Success, "Successfully released devices from pod " + podID
+}
+
+// GetPodDevices returns the list of devices assigned to a pod
+func (m *IBDeviceManager) GetPodDevices(podID string) []string {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+
+	if devices, exists := m.podDevices[podID]; exists {
+		// Return a copy
+		result := make([]string, len(devices))
+		copy(result, devices)
+		return result
+	}
+
+	return nil
+}
+
+// GetAvailableDevices returns a list of available devices
+func (m *IBDeviceManager) GetAvailableDevices() []string {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+
+	var available []string
+	for deviceID, device := range m.devices {
+		if device.GetState() == IBDeviceAvailable {
+			available = append(available, deviceID)
+		}
+	}
+
+	return available
+}
+
+// GetAssignedDevices returns a list of assigned devices
+func (m *IBDeviceManager) GetAssignedDevices() []string {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+
+	var assigned []string
+	for deviceID, device := range m.devices {
+		if device.GetState() == IBDeviceAssigned {
+			assigned = append(assigned, deviceID)
+		}
+	}
+
+	return assigned
+}
+
+// IsValidMacAddress validates MAC address format
+func IsValidMacAddress(mac string) bool {
+	if len(mac) != 17 {
+		return false
+	}
+
+	for i, c := range mac {
+		if i%3 == 2 {
+			if c != ':' {
+				return false
+			}
+		} else {
+			if !((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')) {
+				return false
+			}
+		}
+	}
+
+	return true
+}
+
+// GetIBDeviceManager returns the IB device manager
+func (service *HTTPRestService) GetIBDeviceManager() *IBDeviceManager {
+	return service.ibDeviceManager
+}

cns/restserver/ibdevice.go

@@ -56,7 +56,7 @@ func exampleGRPCClient() {
 		log.Printf("AssignIBDevicesToPod failed: %v", err)
 	} else {
 		log.Printf("Assignment result: code=%d, message=%s",
-			assignResp.CnsCode, assignResp.Message)
+			assignResp.ErrorCode, assignResp.Message)
 	}
 
 	// Example 2: Get device info