public override RegisterStorage?GetRegister(StorageDomain domain, BitRange range)
{
RegisterStorage[] regs;
if (range.Msb <= 8)
{
regs = Registers.RlRegisters;
}
else if (range.Msb <= 16)
{
if (8 <= range.Lsb)
{
regs = Registers.RhRegisters;
}
else
{
regs = Registers.RRegisters;
}
}
else
{
regs = Registers.GpRegisters;
}
var i = domain - regs[0].Domain;
if (0 <= i && i < regs.Length)
{
return(regs[i]);
}
else
{
return(null);
}
}
/// <summary>
/// Gets the required per storage domain data service.
/// </summary>
/// <param name="domain">The domain.</param>
/// <param name="configuration">The configuration.</param>
/// <returns></returns>
public static object GetService(StorageDomain domain, INewsComponentsConfiguration configuration)
{
configuration.ExceptionIfNull("configuration");
IInitDataService service = new FileStorageDataService();
if (domain == StorageDomain.UserCacheData)
{
service.Initialize(Path.Combine(
configuration.UserLocalApplicationDataPath,
"Cache"));
}
else
if (domain == StorageDomain.UserData)
{
service.Initialize(
configuration.UserApplicationDataPath);
}
else
if (domain == StorageDomain.UserRoamingData)
{
service.Initialize(
configuration.UserLocalApplicationDataPath);
}
else
{
Debug.Assert(false, "No data service for StorageDomain: " + domain);
}
return(service);
}
public Storage(string storageKind, StorageDomain domain, string name, DataType dataType)
{
this.Kind = storageKind;
this.Domain = domain;
this.DataType = dataType;
this.Name = name;
}
internal static RegisterStorage?GetRegister(StorageDomain domain, ulong mask)
{
var iReg = domain - StorageDomain.Register;
if (iReg < 0 || iReg >= regsByStorage.Length)
{
return(null);
}
RegisterStorage?regBest = regsByStorage[iReg];
if (regBest is null)
{
return(null);
}
if (SubRegisters.TryGetValue(domain, out var subregs))
{
for (int i = 0; i < subregs.Length; ++i)
{
var reg = subregs[i];
var regMask = reg.BitMask;
if ((mask & (~regMask)) == 0)
{
regBest = reg;
}
}
}
return(regBest);
}
public MemoryStorage(string name, StorageDomain domain) : base(name, name, null !)
{
this.Name = name;
this.Domain = domain;
this.BitAddress = 0;
this.BitSize = 1;
}
public static void Configure(IInitDataService dataService, StorageDomain domain)
{
if (dataService == null)
throw new ArgumentNullException("dataService");
if (domain == StorageDomain.UserCacheData)
{
dataService.Initialize(Path.Combine(
RssBanditApplication.GetLocalUserPath(),
"Cache"));
}
else
if (domain == StorageDomain.UserData)
{
dataService.Initialize(
RssBanditApplication.GetUserPersonalPath());
}
else
if (domain == StorageDomain.UserRoamingData)
{
dataService.Initialize(
RssBanditApplication.GetUserPath());
}
else
Debug.Assert(false, "No data service for StorageDomain: " + domain);
}
/// <summary>
/// Gets the required per storage domain data service.
/// </summary>
/// <param name="domain">The domain.</param>
/// <returns></returns>
public static object GetService(StorageDomain domain)
{
IInitDataService service = new FileStorageDataService();
if (domain == StorageDomain.UserCacheData)
{
service.Initialize(Path.Combine(
RssBanditApplication.GetLocalUserPath(),
"Cache"));
}
else
if (domain == StorageDomain.UserData)
{
service.Initialize(
RssBanditApplication.GetUserPersonalPath());
}
else
if (domain == StorageDomain.UserRoamingData)
{
service.Initialize(
RssBanditApplication.GetUserPath());
}
else
Debug.Assert(false, "No data service for StorageDomain: " + domain);
return service;
}
public override RegisterStorage GetRegister(StorageDomain domain, BitRange range)
{
if (Registers.RegistersByDomain.TryGetValue(domain, out var reg))
return reg;
else
return null;
}
/// <summary>
/// Return storage domain
/// </summary>
/// <param name="name"></param>
/// <param name="sacId"></param>
/// <param name="client"></param>
/// <param name="resourceGroupName"></param>
/// <param name="managerName"></param>
/// <returns></returns>
public static StorageDomain GetStorageDomain(
string name,
string sacId,
StorSimpleManagementClient client,
string resourceGroupName,
string managerName)
{
var storageDomains = client.StorageDomains.ListByManager(resourceGroupName, managerName);
StorageDomain storageDomain = null;
if (storageDomains != null)
{
storageDomain = storageDomains.FirstOrDefault(s =>
s.Name.Equals(
name,
StringComparison.CurrentCultureIgnoreCase));
}
if (storageDomain == null)
{
var sdNew = new StorageDomain(
client,
resourceGroupName,
managerName,
name);
sdNew.Initialize(sacId);
storageDomain = sdNew.CreateOrUpdate();
}
storageDomain.SetBaseResourceValues(client, resourceGroupName, managerName);
return(storageDomain);
}
public void TestDeleteIscsiServer()
{
try
{
var iscsiServers = TestUtilities.GetIscsiServers(
this.Client,
this.ResourceGroupName,
this.ManagerName);
Assert.True(
iscsiServers != null && iscsiServers.Any(),
$"No IscsiServers were found in the manger {this.ManagerName}");
// Select the first IscsiServer
var IscsiServer = iscsiServers.First();
// Get the associated storage domain
StorageDomain sd = TestUtilities.GetStorageDomainById(
IscsiServer.StorageDomainId,
this.Client,
this.ResourceGroupName,
this.ManagerName);
// Get the associated BackupScheduleGroup
var backupScheduleGroup = TestUtilities.GetBackupScheduleGroupById(
IscsiServer.BackupScheduleGroupId,
IscsiServer.Name,
this.Client,
this.ResourceGroupName,
this.ManagerName);
// Delete IscsiServer
TestUtilities.DeleteAndValidateIscsiServer(
this.Client,
this.ResourceGroupName,
this.ManagerName,
IscsiServer.Name,
IscsiServer.Name);
// Delete storage domain
TestUtilities.DeleteStorageDomain(
sd.Name,
this.Client,
this.ResourceGroupName,
this.ManagerName);
// Delete BackupScheduleGroup
TestUtilities.DeleteBackupScheduleGroup(
backupScheduleGroup.Name,
IscsiServer.Name,
this.Client,
this.ResourceGroupName,
this.ManagerName);
}
catch (Exception e)
{
Assert.Null(e);
}
}
public override RegisterStorage GetRegister(StorageDomain domain, BitRange range)
{
int i = domain - StorageDomain.Register;
return((0 <= i && i < regs.Length)
? regs[i]
: null);
}
private static RegisterStorage?GetSubregisterUsingMask(StorageDomain domain, ulong mask)
{
if (mask == 0)
{
return(null);
}
RegisterStorage?reg = null;
if (Registers.SubRegisters.TryGetValue(domain, out RegisterStorage[] subregs))
private static RegisterStorage?GetSubregister(StorageDomain domain, BitRange range)
{
if (range.IsEmpty)
{
return(null);
}
RegisterStorage?reg = null;
if (Registers.SubRegisters.TryGetValue(domain, out RegisterStorage[] subregs))
private bool IsBoundaryCheck(BinaryExpression binExp, StorageDomain domLeft, Expression liveKey)
{
if (domLeft != StorageDomain.Memory)
{
return(DomainOf(liveKey) == domLeft);
}
else
{
return(this.slicer.AreEqual(liveKey, binExp.Left));
}
}
public override RegisterStorage?GetRegister(StorageDomain domain, BitRange range)
{
if (!Registers.RegistersByDomain.TryGetValue(domain, out var reg))
{
return(null);
}
else
{
return(reg);
}
}
public static RegisterStorage GetRegister(StorageDomain domain)
{
if (mpDomainToReg.TryGetValue(domain, out var reg))
{
return(reg);
}
else
{
return(null);
}
}
/// <summary>
/// Initializes StorageDomain instance
/// </summary>
/// <param name="storageDomain"></param>
/// <param name="sacId"></param>
public static void Initialize(this StorageDomain storageDomain, string sacId)
{
var storageAccountCredentialIds = string.IsNullOrEmpty(sacId) ? null : new List <string>()
{
sacId
};
// StorageDomain instance
storageDomain.StorageAccountCredentialIds = storageAccountCredentialIds;
storageDomain.EncryptionStatus = EncryptionStatus.Disabled;
storageDomain.EncryptionKey = null;;
}
public override RegisterStorage?GetRegister(StorageDomain domain, BitRange range)
{
var ireg = domain - StorageDomain.Register;
if (0 <= ireg && ireg < allRegs.Length)
{
return(allRegs[ireg]);
}
else
{
return(null);
}
}
public override RegisterStorage?GetRegister(StorageDomain domain, BitRange range)
{
int i = domain - StorageDomain.Register;
if (regsByNumber.TryGetValue(i, out RegisterStorage reg))
{
return(reg);
}
else
{
return(null);
}
}
public override RegisterStorage GetRegister(StorageDomain regDomain, BitRange range)
{
if (!Registers.Subregisters.TryGetValue(regDomain, out var subs))
{
return(null);
}
int key = (range.Extent << 4) | range.Lsb;
if (!subs.TryGetValue(key, out var subreg))
{
return(null);
}
return(subreg);
}
public override RegisterStorage?GetRegister(StorageDomain regDomain, BitRange range)
{
if (!Subregisters.TryGetValue(regDomain, out var subs))
{
return(null);
}
var key = range.BitMask();
if (!subs.TryGetValue(key, out var subreg))
{
return(null);
}
return(subreg);
}
public override RegisterStorage?GetRegister(StorageDomain domain, BitRange range)
{
bool hi = 8 <= range.Lsb && range.Msb < 16;
bool lo = 0 <= range.Lsb && range.Msb < 8;
switch ((int)domain)
{
case 0: return(lo ? Registers.f : hi?Registers.a : Registers.af);
case 1: return(lo ? Registers.c : hi?Registers.b : Registers.bc);
case 2: return(lo ? Registers.e : hi?Registers.d : Registers.de);
case 3: return(lo ? Registers.l : hi?Registers.h : Registers.hl);
}
return(Registers.ByDomain[domain]);
}
public override RegisterStorage GetRegister(StorageDomain regDomain, BitRange range)
{
if (!Registers.Subregisters.TryGetValue(regDomain, out var subs))
{
return(null);
}
int key = (range.Extent * 4) + range.Lsb;
if (subs.TryGetValue(key, out var subreg))
{
return(subreg);
}
else
{
return(Registers.regs[regDomain - StorageDomain.Register]);
}
}
public override RegisterStorage?GetRegister(StorageDomain domain, BitRange range)
{
var nDomain = (int)domain;
if (0 <= nDomain && nDomain < Registers.GpRegs.Length)
{
if (range.Lsb < 8 && range.Msb <= 8)
{
return(Registers.LoByteRegs[nDomain / 2]);
}
if (range.Lsb >= 8 && range.Msb < 16)
{
return(Registers.HiByteRegs[nDomain / 2]);
}
return(Registers.GpRegs[nDomain]);
}
return(Registers.ByDomain[domain]);
}
public override RegisterStorage?GetRegister(StorageDomain domain, BitRange range)
{
if (domain == Registers.fr0.Domain)
{
// Special case the floating point numbers.
if (range.Extent == 32)
{
return(Registers.fpregs[range.Lsb / 32]);
}
if (range.Extent == 64)
{
return(Registers.dfpregs[range.Lsb / 64]);
}
throw new NotImplementedException("GetRegister: FP registers not done yet.");
}
return(Registers.RegistersByDomain.TryGetValue(domain, out var reg)
? reg
: null);
}
public override RegisterStorage GetRegister(StorageDomain dom, BitRange range)
{
var i = (int)dom;
if (0 <= i && i < Registers.SubRegisters.Length)
{
var subregs = Registers.SubRegisters[i];
var reg = subregs[0];
for (int j = 0; j < subregs.Length; ++j)
{
var subreg = subregs[j];
if ((short)subreg.BitSize < range.Msb)
{
break;
}
reg = subreg;
}
return(reg);
}
return(null);
}
public override RegisterStorage?GetRegister(StorageDomain domain, BitRange range)
{
uint iReg = (uint)domain;
if (iReg < Registers.WordRegs.Length)
{
if (range.Extent != 8)
{
return(Registers.WordRegs[iReg]);
}
iReg *= 2;
if (range.Lsb == 8)
{
++iReg;
}
if (iReg < Registers.ByteRegs.Length)
{
return(Registers.ByteRegs[iReg]);
}
}
return(null);
}
private static RegisterStorage GetSubregisterUsingMask(StorageDomain domain, ulong mask)
{
RegisterStorage[] subregs;
if (mask == 0)
{
return(null);
}
RegisterStorage reg = null;
if (Registers.SubRegisters.TryGetValue(domain, out subregs))
{
for (int i = 0; i < subregs.Length; ++i)
{
var subreg = subregs[i];
var regMask = subreg.BitMask;
if ((mask & (~regMask)) == 0)
{
reg = subreg;
}
}
}
return(reg);
}
/// <summary>
/// Creates or updates StorageDomain
/// </summary>
/// <param name="storageDomain"></param>
/// <returns></returns>
public static StorageDomain CreateOrUpdate(this StorageDomain storageDomain)
{
// Create StorageDomain
var storageDomainCreated = storageDomain.Client.StorageDomains.CreateOrUpdate(
storageDomain.Name.GetDoubleEncoded(),
storageDomain,
storageDomain.ResourceGroupName,
storageDomain.ManagerName);
// Validate StorageDomain
Assert.True(
storageDomain.Name == storageDomainCreated.Name &&
storageDomain.StorageAccountCredentialIds[0].Equals(
storageDomainCreated.StorageAccountCredentialIds[0]) &&
storageDomain.EncryptionStatus == storageDomainCreated.EncryptionStatus,
"Create of StorageDomain failed in validation");
storageDomainCreated.SetBaseResourceValues(
storageDomain.Client,
storageDomainCreated.ResourceGroupName,
storageDomainCreated.ManagerName);
return(storageDomainCreated);
}
/// <summary>
/// Return StorageDomain by Id
/// </summary>
/// <param name="storageDomainId"></param>
/// <param name="client"></param>
/// <param name="resourceGroupName"></param>
/// <param name="managerName"></param>
/// <returns></returns>
public static StorageDomain GetStorageDomainById(
string storageDomainId,
StorSimpleManagementClient client,
string resourceGroupName,
string managerName)
{
var storageDomains = client.StorageDomains.ListByManager(resourceGroupName, managerName);
StorageDomain storageDomain = null;
if (storageDomains != null)
{
storageDomain = storageDomains.FirstOrDefault(s =>
s.Id.Equals(
storageDomainId,
StringComparison.CurrentCultureIgnoreCase));
}
if (storageDomain == null)
{
storageDomain.SetBaseResourceValues(client, resourceGroupName, managerName);
}
return(storageDomain);
}
