ocp-indent auto indent

Signed-off-by: Lin Liu <[email protected]>

Author: liulinC

ocaml/xapi/vgpuops.ml

@@ -61,29 +61,29 @@ let allocate_vgpu_to_gpu ?dry_run ?pre_allocate_list ~__context vm host vgpu =
   let pgpus = List.intersect compatible_pgpus available_pgpus in
 
   let pgpu_can_hold_vgpu pgpu vgpu = 
-      try Xapi_pgpu.assert_can_run_VGPU ~__context ~self:pgpu ~vgpu;
-          true
-      with e -> false in
+    try Xapi_pgpu.assert_can_run_VGPU ~__context ~self:pgpu ~vgpu;
+      true
+    with e -> false in
 
   let active_pgpus = List.filter ( fun pgpu ->  pgpu_can_hold_vgpu pgpu vgpu.vgpu_ref ) pgpus in
 
   let remaining_capacity_for_vgpu_from_pgpu vgpu pgpu = 
     let db_remaining =  Helpers.call_api_functions ~__context 
         (fun rpc session_id ->
-             Client.Client.PGPU.get_remaining_capacity ~rpc ~session_id
-               ~self:pgpu ~vgpu_type:vgpu.type_ref) in
+           Client.Client.PGPU.get_remaining_capacity ~rpc ~session_id
+             ~self:pgpu ~vgpu_type:vgpu.type_ref) in
     (* Check if any pre-allocation existed, the pre-allocation is not reflected
      * in the database, usually in the dry run mode, with following format
      * [(v1,p1);(v2,p2);(v3,p1)...]*)
     match pre_allocate_list with
     | Some pre_allocate_list ->
-        let virtul_allocation = List.fold_left (fun num ele ->
-            match ele with 
-            |(_,cpgpu) when cpgpu = pgpu -> Int64.add num 1L
-            |(_,_) -> num )
-        0L pre_allocate_list in
-            Int64.sub db_remaining  virtul_allocation
-            (* Probablly need check here, assert >0*)
+      let virtul_allocation = List.fold_left (fun num ele ->
+          match ele with 
+          |(_,cpgpu) when cpgpu = pgpu -> Int64.add num 1L
+          |(_,_) -> num )
+          0L pre_allocate_list in
+      Int64.sub db_remaining  virtul_allocation
+    (* Probablly need check here, assert >0*)
     | _ -> db_remaining 
   in
 
@@ -110,16 +110,16 @@ let allocate_vgpu_to_gpu ?dry_run ?pre_allocate_list ~__context vm host vgpu =
   match choose_pgpu sorted_pgpus with
   | None -> fail_creation vm vgpu
   | Some pgpu ->
-      let bneed_db_operation = match dry_run with
-          | Some true ->  false
-          | _ -> true in
-      if bneed_db_operation then
-          Db.VGPU.set_scheduled_to_be_resident_on ~__context ~self:vgpu.vgpu_ref ~value:pgpu;
+    let bneed_db_operation = match dry_run with
+      | Some true ->  false
+      | _ -> true in
+    if bneed_db_operation then
+      Db.VGPU.set_scheduled_to_be_resident_on ~__context ~self:vgpu.vgpu_ref ~value:pgpu;
 
-      let pre_list = match pre_allocate_list with
-          | Some pre_allocate_list -> pre_allocate_list
-          | _ -> [] in
-      (vgpu.vgpu_ref,pgpu)::pre_list
+    let pre_list = match pre_allocate_list with
+      | Some pre_allocate_list -> pre_allocate_list
+      | _ -> [] in
+    (vgpu.vgpu_ref,pgpu)::pre_list
 
 (* Take a PCI device and assign it, and any dependent devices, to the VM *)
 let add_pcis_to_vm ~__context host vm pci =
@@ -149,8 +149,8 @@ let reserve_free_virtual_function ~__context vm pf =
         (* We may still need to load the driver... do that and try again *)
         let pf_host = Db.PCI.get_host ~__context ~self:pf in
         Helpers.call_api_functions ~__context (fun rpc session_id ->
-          Client.Client.Host.mxgpu_vf_setup rpc session_id pf_host
-        );
+            Client.Client.Host.mxgpu_vf_setup rpc session_id pf_host
+          );
         get false
       end else
         (* This probably means that our capacity checking went wrong! *)
@@ -198,7 +198,7 @@ let vgpu_manual_setup_of_vm vm_r =
 let create_vgpus ~__context host (vm, vm_r) hvm =
   let vgpus = vgpus_of_vm ~__context vm_r in
   if vgpus <> [] && not hvm then
-      raise (Api_errors.Server_error (Api_errors.feature_requires_hvm, ["vGPU- and GPU-passthrough needs HVM"]));
+    raise (Api_errors.Server_error (Api_errors.feature_requires_hvm, ["vGPU- and GPU-passthrough needs HVM"]));
   add_vgpus_to_vm ~__context host vm vgpus (vgpu_manual_setup_of_vm vm_r)
 
 (* This function is called from Xapi_xenops, after forwarding, so possibly on a slave. *)

ocaml/xapi/xapi_pgpu.ml

@@ -317,8 +317,8 @@ let assert_can_run_VGPU ~__context ~self ~vgpu =
   (** Check whether Nvidia NVML allow the vGPU by gpumon *)
   let nvidia_compatible = Xapi_gpumon.Nvidia.vgpu_pgpu_are_compatible ~__context ~vgpu ~pgpu:self in
   if not nvidia_compatible then raise (Api_errors.Server_error
-  (** This should be a new exception **)
-    (Api_errors.pgpu_insufficient_capacity_for_vgpu, [Ref.string_of self;Ref.string_of vgpu_type]))
+                                         (** This should be a new exception **)
+                                         (Api_errors.pgpu_insufficient_capacity_for_vgpu, [Ref.string_of self;Ref.string_of vgpu_type]))
 
 
 let update_dom0_access ~__context ~self ~action =

ocaml/xapi/xapi_pgpu_helpers.ml

@@ -55,25 +55,25 @@ let assert_VGPU_type_allowed ~__context ~self ~vgpu_type =
   match allocated_vgpu_list with
   | [] -> () (* Not allocated on this pgpu, does not need to check compatibility*)
   | hd::tail -> 
-      let grant_vgpu_type_list = List.fold_left
-          (fun grant_list current_list -> Listext.List.intersect grant_list current_list) 
-          (Db.VGPU_type.get_compatible_types_on_pgpu ~__context ~self:(Db.VGPU.get_type ~__context ~self:hd))
-          (
-              List.map (fun self -> Db.VGPU.get_type ~__context ~self) tail
-              |> List.sort_uniq Pervasives.compare (* Remove the duplicated elements*)
-              |> List.map (fun self -> Db.VGPU_type.get_compatible_types_on_pgpu ~__context ~self)
-          ) in
-          if not (List.mem vgpu_type (List.map Ref.of_string (*Remove this when String-> Ref *) grant_vgpu_type_list)) then
-              let sep = ";" in
-              raise (Api_errors.Server_error (
-                  Api_errors.vgpu_type_not_compatible_with_running_type, [
-                      Ref.string_of self;
-                      Ref.string_of vgpu_type;
-                      List.map (fun self-> Db.VGPU.get_type ~__context ~self) allocated_vgpu_list 
-                      |> List.sort_uniq Pervasives.compare
-                      |> List.map (fun vgpu_ref -> Ref.string_of vgpu_ref)
-                      |> String.concat sep
-                  ]))
+    let grant_vgpu_type_list = List.fold_left
+        (fun grant_list current_list -> Listext.List.intersect grant_list current_list) 
+        (Db.VGPU_type.get_compatible_types_on_pgpu ~__context ~self:(Db.VGPU.get_type ~__context ~self:hd))
+        (
+          List.map (fun self -> Db.VGPU.get_type ~__context ~self) tail
+          |> List.sort_uniq Pervasives.compare (* Remove the duplicated elements*)
+          |> List.map (fun self -> Db.VGPU_type.get_compatible_types_on_pgpu ~__context ~self)
+        ) in
+    if not (List.mem vgpu_type (List.map Ref.of_string (*Remove this when String-> Ref *) grant_vgpu_type_list)) then
+      let sep = ";" in
+      raise (Api_errors.Server_error (
+          Api_errors.vgpu_type_not_compatible_with_running_type, [
+            Ref.string_of self;
+            Ref.string_of vgpu_type;
+            List.map (fun self-> Db.VGPU.get_type ~__context ~self) allocated_vgpu_list 
+            |> List.sort_uniq Pervasives.compare
+            |> List.map (fun vgpu_ref -> Ref.string_of vgpu_ref)
+            |> String.concat sep
+          ]))
 
 let assert_no_resident_VGPUs_of_type ~__context ~self ~vgpu_type =
   let open Db_filter_types in
@@ -222,9 +222,9 @@ let assert_destination_has_pgpu_compatible_with_vm ~__context ~vm ~vgpu_map ~hos
     | `nvidia ->
       Db.VGPU.get_GPU_group ~__context ~self:vgpu
       |> fun self -> Db.GPU_group.get_GPU_types ~__context ~self
-      |> fun pgpu_types -> get_first_suitable_pgpu pgpu_types vgpu pgpus
-      |> fun pgpu ->
-        assert_destination_pgpu_is_compatible_with_vm ~__context ~vm ~vgpu ~pgpu ~host ?remote ()
+                     |> fun pgpu_types -> get_first_suitable_pgpu pgpu_types vgpu pgpus
+                                          |> fun pgpu ->
+                                          assert_destination_pgpu_is_compatible_with_vm ~__context ~vm ~vgpu ~pgpu ~host ?remote ()
   in
   let vgpus = Db.VM.get_VGPUs ~__context ~self:vm in
   let _mapped, unmapped = List.partition (fun vgpu -> List.mem_assoc vgpu vgpu_map) vgpus in

ocaml/xapi/xapi_vm_helpers.ml

@@ -49,7 +49,7 @@ let ensure_domain_type_is_specified ~__context ~self =
   if Db.VM.get_domain_type ~__context ~self = `unspecified then
     Db.VM.get_HVM_boot_policy ~__context ~self
     |> fun hbp -> derive_domain_type ~hVM_boot_policy:hbp
-    |> fun value -> Db.VM.set_domain_type ~__context ~self ~value
+                  |> fun value -> Db.VM.set_domain_type ~__context ~self ~value
 
 let derive_hvm_boot_policy ~domain_type =
   if domain_type = `hvm then
@@ -239,17 +239,17 @@ let validate_basic_parameters ~__context ~self ~snapshot:x =
 let assert_vm_supports_quiesce_snapshot ~__context ~self =
   let vmr = Db.VM.get_record_internal ~__context ~self in
   if List.exists ( fun vbd ->
-    try
-      let vdi = Db.VBD.get_VDI ~__context ~self:vbd in
-      let sm_config = Db.VDI.get_sm_config ~__context ~self:vdi in
-      Xapi_vm_lifecycle.assoc_opt "on_boot" sm_config = Some "reset"
-    with _ -> false
-  ) vmr.Db_actions.vM_VBDs then
+      try
+        let vdi = Db.VBD.get_VDI ~__context ~self:vbd in
+        let sm_config = Db.VDI.get_sm_config ~__context ~self:vdi in
+        Xapi_vm_lifecycle.assoc_opt "on_boot" sm_config = Some "reset"
+      with _ -> false
+    ) vmr.Db_actions.vM_VBDs then
     raise (Api_errors.Server_error(Api_errors.vdi_on_boot_mode_incompatible_with_operation, [ ]));
 
   let vmgmr = Xapi_vm_lifecycle.maybe_get_guest_metrics ~__context ~ref:(vmr.Db_actions.vM_guest_metrics) in
   if not ((Xapi_vm_lifecycle.has_feature ~vmgmr ~feature:"feature-snapshot") ||
-    (Xapi_vm_lifecycle.has_feature ~vmgmr ~feature:"feature-quiesce")) then
+          (Xapi_vm_lifecycle.has_feature ~vmgmr ~feature:"feature-quiesce")) then
     raise (Api_errors.Server_error(Api_errors.vm_snapshot_with_quiesce_not_supported, [ Ref.string_of self ]))
 
 let assert_hardware_platform_support ~__context ~vm ~host =
@@ -361,27 +361,27 @@ let assert_gpus_available ~__context ~self ~host =
   let vgpus = Db.VM.get_VGPUs ~__context ~self in
   let open Vgpuops in
   let vgpurs = List.map (Vgpuops.vgpu_of_ref ~__context)  vgpus in
-    try
-        ignore (List.fold_left (fun pre_allocate_list vgpu -> Vgpuops.allocate_vgpu_to_gpu ~dry_run:true ~pre_allocate_list ~__context self host vgpu) [] vgpurs) 
-    with _ -> raise (Api_errors.Server_error (Api_errors.vm_requires_gpu, [
-        Ref.string_of self;  
-        String.concat ";" (List.map Ref.string_of vgpus)
-      ]))
+  try
+    ignore (List.fold_left (fun pre_allocate_list vgpu -> Vgpuops.allocate_vgpu_to_gpu ~dry_run:true ~pre_allocate_list ~__context self host vgpu) [] vgpurs) 
+  with _ -> raise (Api_errors.Server_error (Api_errors.vm_requires_gpu, [
+      Ref.string_of self;  
+      String.concat ";" (List.map Ref.string_of vgpus)
+    ]))
 
 
 let assert_usbs_available ~__context ~self ~host =
   Db.VM.get_VUSBs ~__context ~self
   |> List.iter (fun vusb ->
-    try
-      let usb_group = Db.VUSB.get_USB_group ~__context ~self:vusb in
-      let pusb = List.hd (Db.USB_group.get_PUSBs ~__context ~self:usb_group) in
-      let usb_host = Db.PUSB.get_host ~__context ~self:pusb in
-      assert (usb_host = host)
-    with _ -> raise (Api_errors.Server_error (Api_errors.operation_not_allowed,
-      [Printf.sprintf "VUSB %s is not available on Host %s"
-        (Ref.string_of vusb)
-        (Ref.string_of host)
-      ]))
+      try
+        let usb_group = Db.VUSB.get_USB_group ~__context ~self:vusb in
+        let pusb = List.hd (Db.USB_group.get_PUSBs ~__context ~self:usb_group) in
+        let usb_host = Db.PUSB.get_host ~__context ~self:pusb in
+        assert (usb_host = host)
+      with _ -> raise (Api_errors.Server_error (Api_errors.operation_not_allowed,
+                                                [Printf.sprintf "VUSB %s is not available on Host %s"
+                                                   (Ref.string_of vusb)
+                                                   (Ref.string_of host)
+                                                ]))
     )
 
 (* 1.To avoid redundant checks,for each VF if it was reserved, then it's no need to check remaining capacity again.
@@ -398,9 +398,9 @@ let assert_netsriov_available ~__context ~self ~host =
           let required, pif = List.assoc network acc in
           (network,(required + 1,pif)) :: (List.remove_assoc network acc)
         with Not_found ->
-          match Xapi_network_sriov_helpers.get_local_underlying_pif ~__context ~network ~host with
-          | Some pif -> (network,(1,pif)) :: acc
-          | None -> acc
+        match Xapi_network_sriov_helpers.get_local_underlying_pif ~__context ~network ~host with
+        | Some pif -> (network,(1,pif)) :: acc
+        | None -> acc
       end
     ) [] (Db.VM.get_VIFs ~__context ~self)
   in
@@ -442,9 +442,9 @@ let assert_enough_memory_available ~__context ~self ~host ~snapshot =
 let assert_matches_control_domain_affinity ~__context ~self ~host =
   if Db.VM.get_is_control_domain ~__context ~self then
     match Db.VM.get_affinity ~__context ~self with
-     | x when x = Ref.null || x = host -> ()
-     | _ -> raise (Api_errors.Server_error (Api_errors.operation_not_allowed,
-             ["Cannot boot a control domain on a host different from its affinity"]))
+    | x when x = Ref.null || x = host -> ()
+    | _ -> raise (Api_errors.Server_error (Api_errors.operation_not_allowed,
+                                           ["Cannot boot a control domain on a host different from its affinity"]))
 
 let assert_enough_pcpus ~__context ~self ~host ?remote () =
   let vcpus = Db.VM.get_VCPUs_max ~__context ~self in
@@ -457,13 +457,13 @@ let assert_enough_pcpus ~__context ~self ~host ?remote () =
     let platformdata = Db.VM.get_platform ~__context ~self in
     if Vm_platform.(is_true ~key:vcpu_unrestricted ~platformdata ~default:false) then
       warn "Allowing VM %s to run on host %s, even though #vCPUs > #pCPUs (%Ld > %Ld), \
-        because platform:vcpu-unrestricted is set"
+            because platform:vcpu-unrestricted is set"
         (Ref.string_of self) (Ref.string_of host) vcpus pcpus
     else
       raise Api_errors.(Server_error (
-        host_not_enough_pcpus,
-        List.map Int64.to_string [vcpus; pcpus]
-      ))
+          host_not_enough_pcpus,
+          List.map Int64.to_string [vcpus; pcpus]
+        ))
 
 (** Checks to see if a VM can boot on a particular host, throws an error if not.
  * Criteria:
@@ -508,9 +508,9 @@ let assert_can_boot_here ~__context ~self ~host ~snapshot ?(do_sr_check=true) ?(
   assert_usbs_available ~__context ~self ~host;
   assert_netsriov_available ~__context ~self ~host;
   begin match Helpers.domain_type ~__context ~self with
-  | `hvm | `pv_in_pvh ->
-    assert_host_supports_hvm ~__context ~self ~host
-  | `pv -> ()
+    | `hvm | `pv_in_pvh ->
+      assert_host_supports_hvm ~__context ~self ~host
+    | `pv -> ()
   end;
   if do_memory_check then
     assert_enough_memory_available ~__context ~self ~host ~snapshot;
@@ -633,8 +633,8 @@ let vm_can_run_on_host ~__context ~vm ~snapshot ~do_memory_check host =
     try let _ = List.find (fun s -> snd s = `evacuate) (Db.Host.get_current_operations ~__context ~self:host) in false with _ -> true
   in
   try host_has_proper_version ()
-    && (is_control_domain || host_enabled ()) (*CA-233580: allow control domains to start on a disabled host*)
-    && host_live () && host_can_run_vm () && host_evacuate_in_progress
+      && (is_control_domain || host_enabled ()) (*CA-233580: allow control domains to start on a disabled host*)
+      && host_live () && host_can_run_vm () && host_evacuate_in_progress
   with _ -> false
 
 
@@ -716,7 +716,7 @@ let choose_host_for_vm_no_wlb ~__context ~vm ~snapshot =
     | `VGPU vgpu -> group_hosts_by_best_pgpu ~__context vgpu
     | `Netsriov network ->
       let host_group = Xapi_network_sriov_helpers.group_hosts_by_best_sriov ~__context ~network
-        |> List.map (fun g -> List.map (fun (h,_)-> h) g)
+                       |> List.map (fun g -> List.map (fun (h,_)-> h) g)
       in
       if host_group <> [] then host_group
       else raise (Api_errors.Server_error(Api_errors.network_sriov_insufficient_capacity, [Ref.string_of network]))
@@ -771,9 +771,9 @@ let choose_host_for_vm ~__context ~vm ~snapshot =
             | ["WLB"; "0.0"; rec_id; zero_reason] ->
               filter_and_convert tl
             | ["WLB"; stars; rec_id] ->
-                let st = try float_of_string stars with Failure _ -> raise Float_of_string_failure
-                in
-                (h, st, rec_id) :: filter_and_convert tl
+              let st = try float_of_string stars with Failure _ -> raise Float_of_string_failure
+              in
+              (h, st, rec_id) :: filter_and_convert tl
             | _ -> filter_and_convert tl
           end
         | [] -> []
@@ -1075,20 +1075,20 @@ let assert_valid_bios_strings ~__context ~value =
   (* Validate size of value provided is within bios_string_limit_size and not empty *)
   (* Validate value chars are printable ASCII characters *)
   value |> List.iter (fun (k, v) ->
-    if not (List.mem k Xapi_globs.settable_vm_bios_string_keys) then
-      raise (Api_errors.Server_error(Api_errors.invalid_value, [k; "Unknown key"]));
-    match String.length v with
-    | 0 -> raise (Api_errors.Server_error(Api_errors.invalid_value, [k; "Value provided is empty"]))
-    | len when len > Xapi_globs.bios_string_limit_size ->
-      let err = Printf.sprintf "%s has length more than %d characters" v Xapi_globs.bios_string_limit_size in
-      raise (Api_errors.Server_error(Api_errors.invalid_value, [k; err]))
-    | _ ->
-      String.iter
-        (fun c ->
-          if c < (Char.chr 32) || c >= (Char.chr 127) then
-            raise (Api_errors.Server_error(Api_errors.invalid_value, [k; v ^ " has non-printable ASCII characters"]))
-        ) v
-  )
+      if not (List.mem k Xapi_globs.settable_vm_bios_string_keys) then
+        raise (Api_errors.Server_error(Api_errors.invalid_value, [k; "Unknown key"]));
+      match String.length v with
+      | 0 -> raise (Api_errors.Server_error(Api_errors.invalid_value, [k; "Value provided is empty"]))
+      | len when len > Xapi_globs.bios_string_limit_size ->
+        let err = Printf.sprintf "%s has length more than %d characters" v Xapi_globs.bios_string_limit_size in
+        raise (Api_errors.Server_error(Api_errors.invalid_value, [k; err]))
+      | _ ->
+        String.iter
+          (fun c ->
+             if c < (Char.chr 32) || c >= (Char.chr 127) then
+               raise (Api_errors.Server_error(Api_errors.invalid_value, [k; v ^ " has non-printable ASCII characters"]))
+          ) v
+    )
 
 let copy_bios_strings ~__context ~vm ~host =
   (* only allow to fill in BIOS strings if they are not yet set *)
@@ -1153,9 +1153,9 @@ let ensure_device_model_profile_present ~__context ~domain_type ~is_a_template ?
   let trad    = Vm_platform.(device_model, fallback_device_model_stage_1) in
   if is_a_template then platform
   else
-    if not needs_qemu || List.mem_assoc Vm_platform.device_model platform then
-      (* upgrade existing Device Model entry *)
-      platform |> List.map (fun entry -> if entry = trad then default else entry)
-    else (* only add device-model to an HVM VM platform if it is not already there *)
-      default :: platform
+  if not needs_qemu || List.mem_assoc Vm_platform.device_model platform then
+    (* upgrade existing Device Model entry *)
+    platform |> List.map (fun entry -> if entry = trad then default else entry)
+  else (* only add device-model to an HVM VM platform if it is not already there *)
+    default :: platform