extend_bmc/golang/update_bmc_firmware · dev · Bergen.It / ems-sdk · Mos.Hub

{
  "device": {
    "device_id": "test",
    "connectors": [
      {
        "address": "192.168.1.55",
        "credentials": [
          {
            "login": "root",
            "password": "1qaz@WSX",
            "port": 443,
            "protocol": "CONNECTOR_PROTOCOL_REDFISH"
          }
        ]
      }
    ],
  }
  "firmware_url": "https://url.com/test_firmware.hpm",
  "mode": "BMC_FIRMWARE_UPDATE_MODE_API"
}
  - vendor: Huawei
    model: 2288H V5
    simple_update:
      url: /redfish/v1/UpdateService/Actions/UpdateService.SimpleUpdate
      request: '{"ImageURI": "{filePath}", "TransferProtocol": "{protocol}"}'
func (r *redfishService) huaweiUpdateFirmware(
 filePath string,
 host Host,
 cfg RedfishCFG,
 redfish *rfish.RedfishAdapter,
) error {
 if !strings.HasPrefix(filePath, SFTP) {
  return ErrHuaweiWrongFilePath
 }

 h, id, err := redfish.CreateSession(host.Headers, host.User, host.Password)
 if err != nil {
  return fmt.Errorf("CreateSession failed: %w", err)
 }

 _, ok := h[AuthHeader]
 if !ok {
  return ErrEmptyAuthToken
 }

 if err := r.updateFirmware(h, filePath, "@odata.id", "TaskState", cfg, redfish); err != nil {
  return fmt.Errorf("updateFirmware failed: %w", err)
 }

 if err := redfish.DeleteSession(h, id); err != nil {
  return fmt.Errorf("DeleteSession failed: X-Auth-Token: %s: Id: %q", h[AuthHeader], id)
 }

 return nil
}
func (ra *RedfishAdapter) CreateSession(headers map[string]string, username, password string) (map[string]string, string, error) {
 p := fmt.Sprintf("{\"UserName\": \"%s\", \"Password\": \"%s\"}", username, password)
 payload := make(map[string]any)
 if err := json.Unmarshal([]byte(p), &payload); err != nil {
  return nil, "", err
 }
 sessionURL := "/redfish/v1/SessionService/Sessions"
 resp, err := ra.client.PostWithHeaders(sessionURL, payload, headers)
 if err != nil {
  return nil, "", err
 }
 defer resp.Body.Close()
 var result = make(map[string]any)
 if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
  return nil, "", err
 }

 var id string
 x, ok := result["Id"]
 if ok {
  id = x.(string)
 }

 if resp.StatusCode != http.StatusCreated {
  return nil, "", ErrCreateSession
 }

 authToken := resp.Header.Get(AuthHeader)
 if authToken == "" {
  return nil, "", ErrGetAuthToken
 }

 headers[AuthHeader] = authToken

 return headers, id, nil
}
func (ra *RedfishAdapter) PostWithHeaders(headers map[string]string, updateURL, body string) (*http.Response, error) {
 payload := make(map[string]any)
 if err := json.Unmarshal([]byte(body), &payload); err != nil {
  return nil, fmt.Errorf("unmarshal payload: %w", err)
 }

 resp, err := ra.client.PostWithHeaders(updateURL, payload, headers)
 if err != nil {
  return nil, fmt.Errorf("error when try request to update: %w", err)
 }

 return resp, nil
}
func (r *redfishService) monitoringUpdFirmware(taskMonitor, state string, redfish *rfish.RedfishAdapter) error {
 ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
 defer cancel()
 var getTaskErr error
 for {
  select {
  default:
   // каждый раз делаем запрос по пути мониторинга для получения свежей информации
   resp, err := redfish.GetTaskMonitor(taskMonitor)
   if err != nil {
    if getTaskErr == nil {
     getTaskErr = &RedfishRequestErr{Origin: err}
    }
    continue
   }

   switch resp.StatusCode {
   case http.StatusNoContent, http.StatusOK:
    if resp.ContentLength <= 0 {
     return nil
    }
   case http.StatusAccepted:
    continue
   }

   var result map[string]any
   if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
    return fmt.Errorf("unmarshal response from task service: %w", err)
   }
   resp.Body.Close()

   states, ok := result[state].(string)
   if !ok {
    return fmt.Errorf(
     "failed assert states: states value: [%s] status: [%v] content lenght: [%v]",
     states,
     resp.StatusCode,
     resp.ContentLength,
    )
   }
   states = strings.ToLower(states)
   switch states {
   case "completed", "ok":
    return nil
   case "exception", "error", "critical":
    return fmt.Errorf("failed task for updating source: [%s]", result)
   }

  case <-ctx.Done():
   return fmt.Errorf("%w: %s", ctx.Err(), getTaskErr.Error())
  }
 }
}