/// <summary>
/// Cria um disco virtual
/// </summary>
/// <param name="disks">Lista de disco do VD</param>
/// <param name="enclousure">Controladora que gerencia o VD</param>
/// <param name="level">Nivel do RAID</param>
/// <param name="size">Tamanho do VD</param>
/// <param name="stripeSize">Representa o OptimumIOSizeBytes</param>
/// <param name="name">Nome do VD a ser criado</param>
/// <returns>Job da operação</returns>
public async Task <IdracJob> CreateVirtualDiskAsync(List <PhysicalDisk> disks, Enclousure enclousure, string level, long size, long stripeSize, string name)
{
List <OdataObject> drives = new List <OdataObject>();
foreach (var disk in disks)
{
drives.Add(new OdataObject()
{
Id = disk.OdataId
});
}
var content = new
{
VolumeType = level,
Drives = drives,
CapacityBytes = size,
OptimumIOSizeBytes = stripeSize,
Name = name
};
var jsonContent = JsonConvert.SerializeObject(content);
var httpContent = new StringContent(jsonContent, Encoding.UTF8, "application/json");
var idrac = new JobController(Server);
return(await idrac.CreateJobAsync(string.Format("{0}{1}/Volumes", BaseUri, enclousure.OdataId), httpContent));
}
/// <summary>
/// Deleta um disco virtual
/// </summary>
/// <param name="volume">Objeto contendo o disco virtual</param>
/// <returns>Job de exclusão do VD</returns>
public async Task <IdracJob> DeleteVirtualDiskAsync(VirtualDisk volume)
{
if (volume == null)
{
throw new ArgumentNullException("volume", "O argumento não pode ser nulo");
}
var idrac = new JobController(Server);
return(await idrac.CreateJobAsync(BaseUri + volume.OdataId, HttpMethod.Delete));
}
/// <summary>
/// Realiza a instalação do firmware utilizando o metodo padrão DTMF
/// </summary>
/// <param name="location">Localização do firmware a ser instalado</param>
/// <returns>Job de atualização de firmware</returns>
private async Task <IdracJob> DeviceSimpleUpdateAsync(string location)
{
var content = new
{
ImageURI = location
};
string jsonContent = JsonConvert.SerializeObject(content);
var httpContent = new StringContent(jsonContent, Encoding.UTF8, "application/json");
var idrac = new JobController(Server);
return(await idrac.CreateJobAsync(BaseUri + SimpleUpdate, httpContent));
}
/// <summary>
/// Realiza a instalação do Firmware na Idrac
/// </summary>
/// <param name="location">Uri do recurso</param>
/// <param name="option">Modo de Instalação</param>
/// <returns>Job de Instação fo Firmware</returns>
private async Task <IdracJob> DellUpdateServiceAsync(Uri location, string option)
{
var uris = new List <string>()
{
location.ToString()
};
var content = new
{
SoftwareIdentityURIs = uris,
InstallUpon = option
};
string jsonContent = JsonConvert.SerializeObject(content);
var httpContent = new StringContent(jsonContent, Encoding.UTF8, "application/json");
var idrac = new JobController(Server);
return(await idrac.CreateJobAsync(BaseUri + DellUpdateService, httpContent));
}
/// <summary>
/// Exporta um Server Configuration Profile para um servidor que suporta Redfish
/// </summary>
/// <param name="target">Parametros que serão incluidos no arquivo</param>
/// <returns></returns>
public async Task <IdracJob> ExportScpFileAsync(string target, string exportUse)
{
var content = new
{
ExportFormat = "XML",
ShareParameters = new
{
Target = target
},
ExportUse = exportUse
};
var jsonContent = JsonConvert.SerializeObject(content);
var httpContent = new StringContent(jsonContent, Encoding.UTF8, "application/json");
var idrac = new JobController(Server);
return(await idrac.CreateJobAsync(BaseUri + ExportSystemConfiguration, httpContent));
}
/// <summary>
/// Importa um arquivo do tipo Server Configuration Profile para um servidor com suporte a Redfish
/// </summary>
/// <param name="file">Caminho completo do arquvio SCP</param>
/// <param name="target">Atributos que sofrerão alteração</param>
/// <param name="shutdown">Método de desligamento, caso necessario</param>
/// <param name="status">Status do servidor On/Off</param>
/// <returns></returns>
public async Task <IdracJob> ImportScpFileAsync(string file, string target, string shutdown, string status)
{
string fileLines = File.ReadAllText(file);
var content = new
{
ImportBuffer = fileLines,
ShareParameters = new
{
Target = target
},
ShutdownType = shutdown,
HostPowerState = status
};
var jsonContent = JsonConvert.SerializeObject(content);
var httpContent = new StringContent(jsonContent, Encoding.UTF8, "application/json");
var idrac = new JobController(Server);
return(await idrac.CreateJobAsync(BaseUri + ImportSystemConfiguration, httpContent));
}
/// <summary>
/// Retorna os dados obtidos de um export de arquivo SCP
/// </summary>
/// <param name="jobId">Identificação do Job em que foi criado o SCP</param>
/// <returns>Dados do arquivo</returns>
public async Task <string> GetScpFileDataAsync(string jobId)
{
var idrac = new JobController(Server);
using (var response = await idrac.GetJobDataAsync(jobId))
{
if (response.StatusCode == System.Net.HttpStatusCode.Forbidden)
{
throw new UnauthorizedAccessException("Acesso negado, verifique usuario/senha");
}
if (!response.IsSuccessStatusCode)
{
throw new HttpRequestException("Falha ao receber dados do Export: " + response.RequestMessage);
}
return(await response.Content.ReadAsStringAsync());
}
}
