Vault IOperationSource <Vault> .CreateResult(Response response, CancellationToken cancellationToken)
{
using var document = JsonDocument.Parse(response.ContentStream);
var data = VaultData.DeserializeVaultData(document.RootElement);
return(new Vault(_armClient, data));
}
private void ValidateVault(
VaultData vaultData,
string expectedVaultName,
string expectedResourceGroupName,
string expectedSubId,
Guid expectedTenantId,
string expectedLocation,
string expectedSkuFamily,
SkuName expectedSku,
bool expectedEnabledForDeployment,
bool expectedEnabledForTemplateDeployment,
bool expectedEnabledForDiskEncryption,
bool?expectedEnableSoftDelete,
AccessPolicyEntry[] expectedPolicies,
Dictionary <string, string> expectedTags)
{
Assert.NotNull(vaultData);
Assert.NotNull(vaultData.Properties);
string resourceIdFormat = "/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.KeyVault/vaults/{2}";
string expectedResourceId = string.Format(resourceIdFormat, expectedSubId, expectedResourceGroupName, expectedVaultName);
Assert.AreEqual(expectedResourceId, vaultData.Id.ToString());
Assert.AreEqual(expectedLocation, vaultData.Location);
Assert.AreEqual(expectedTenantId, vaultData.Properties.TenantId);
Assert.AreEqual(expectedSku, vaultData.Properties.Sku.Name);
Assert.AreEqual(expectedVaultName, vaultData.Name);
Assert.AreEqual(expectedEnabledForDeployment, vaultData.Properties.EnabledForDeployment);
Assert.AreEqual(expectedEnabledForTemplateDeployment, vaultData.Properties.EnabledForTemplateDeployment);
Assert.AreEqual(expectedEnabledForDiskEncryption, vaultData.Properties.EnabledForDiskEncryption);
Assert.AreEqual(expectedEnableSoftDelete, vaultData.Properties.EnableSoftDelete);
Assert.True(expectedTags.DictionaryEqual(vaultData.Tags));
Assert.True(expectedPolicies.IsEqual(vaultData.Properties.AccessPolicies));
}
public VaultData ReadVault(Account acc)
{
var cmd = CreateQuery();
cmd.CommandText = "SELECT chestId, items FROM vaults WHERE accId=@accId;";
cmd.Parameters.AddWithValue("@accId", acc.AccountId);
using (var rdr = cmd.ExecuteReader())
{
if (rdr.HasRows)
{
VaultData ret = new VaultData()
{
Chests = new List <VaultChest>()
};
while (rdr.Read())
{
ret.Chests.Add(new VaultChest()
{
ChestId = rdr.GetInt32("chestId"),
_Items = rdr.GetString("items")
});
}
return(ret);
}
else
{
return(new VaultData()
{
Chests = new List <VaultChest>()
});
}
}
}
void LoadVault()
{
VaultData data = SaveSystem.LoadVault();
Vault.money = data.money;
Vault.chances = data.chances;
}
internal static VaultListResult DeserializeVaultListResult(JsonElement element)
{
Optional <IReadOnlyList <VaultData> > value = default;
Optional <string> nextLink = default;
foreach (var property in element.EnumerateObject())
{
if (property.NameEquals("value"))
{
if (property.Value.ValueKind == JsonValueKind.Null)
{
property.ThrowNonNullablePropertyIsNull();
continue;
}
List <VaultData> array = new List <VaultData>();
foreach (var item in property.Value.EnumerateArray())
{
array.Add(VaultData.DeserializeVaultData(item));
}
value = array;
continue;
}
if (property.NameEquals("nextLink"))
{
nextLink = property.Value.GetString();
continue;
}
}
return(new VaultListResult(Optional.ToList(value), nextLink.Value));
}
//Create the header and payload for a string
public void createMessage(string data)
{
string hash = NetworkScript.CalculateHash(data);
VaultData payload = new VaultData(VaultData.NetworkMessageT.PAYLOAD, data);
VaultData header = new VaultData(VaultData.NetworkMessageT.INFO, data.Length, hash);
toServerQueue.Enqueue(header);
toServerQueue.Enqueue(payload);
this.recentMessages.Add(hash, data);
}
public static void SaveVault()
{
BinaryFormatter formatter = new BinaryFormatter();
string path = Application.persistentDataPath + "/vault.nt";
FileStream stream = new FileStream(path, FileMode.Create);
VaultData data = new VaultData();
formatter.Serialize(stream, data);
stream.Close();
}
public static bool IsEqual(this DeletedVaultResource deletedVault, VaultData createdVault)
{
Assert.AreEqual(createdVault.Location, deletedVault.Data.Properties.Location);
Assert.AreEqual(createdVault.Name, deletedVault.Data.Name);
Assert.AreEqual(createdVault.Id, deletedVault.Data.Properties.VaultId);
Assert.AreEqual("Microsoft.KeyVault/deletedVaults", deletedVault.Data.ResourceType);
Assert.True(createdVault.Tags.DictionaryEqual(deletedVault.Data.Properties.Tags));
Assert.NotNull(deletedVault.Data.Properties.ScheduledPurgeOn);
Assert.NotNull(deletedVault.Data.Properties.DeletionOn);
Assert.NotNull(deletedVault.Id);
return(true);
}
public async Task KeyVaultManagementVaultCreateWithoutAccessPolicies()
{
IgnoreTestInLiveMode();
VaultProperties vaultProperties = new VaultProperties(TenantIdGuid, new KeyVaultSku(KeyVaultSkuFamily.A, KeyVaultSkuName.Standard));
VaultCreateOrUpdateContent content = new VaultCreateOrUpdateContent(Location, vaultProperties);
ArmOperation <VaultResource> rawVault = await VaultCollection.CreateOrUpdateAsync(WaitUntil.Completed, VaultName, content);
VaultData createdVault = rawVault.Value.Data;
Assert.IsNotNull(createdVault);
Assert.AreEqual(VaultName, createdVault.Name);
}
public static bool IsEqual(this VaultData vault1, VaultData vault2)
{
Assert.AreEqual(vault2.Location, vault1.Location);
Assert.AreEqual(vault2.Name, vault1.Name);
Assert.AreEqual(vault2.Id, vault1.Id);
Assert.True(vault2.Tags.DictionaryEqual(vault1.Tags));
Assert.AreEqual(vault2.Properties.VaultUri.ToString().TrimEnd('/'), vault1.Properties.VaultUri.ToString().TrimEnd('/'));
Assert.AreEqual(vault2.Properties.TenantId, vault1.Properties.TenantId);
Assert.AreEqual(vault2.Properties.Sku.Name, vault1.Properties.Sku.Name);
Assert.AreEqual(vault2.Properties.EnableSoftDelete, vault1.Properties.EnableSoftDelete);
Assert.AreEqual(vault2.Properties.EnabledForTemplateDeployment, vault1.Properties.EnabledForTemplateDeployment);
Assert.AreEqual(vault2.Properties.EnabledForDiskEncryption, vault1.Properties.EnabledForDiskEncryption);
Assert.AreEqual(vault2.Properties.EnabledForDeployment, vault1.Properties.EnabledForDeployment);
Assert.True(vault2.Properties.AccessPolicies.IsEqual(vault1.Properties.AccessPolicies));
return(true);
}
public static VaultData LoadVault()
{
string path = Application.persistentDataPath + "/vault.nt";
if (File.Exists(path))
{
BinaryFormatter formatter = new BinaryFormatter();
FileStream stream = new FileStream(path, FileMode.Open);
VaultData data = formatter.Deserialize(stream) as VaultData;
stream.Close();
return(data);
}
else
{
Debug.LogError("Save file not found in " + path);
return(null);
}
}
private void ValidateVault(
VaultData vaultData,
string expectedVaultName,
string expectedResourceGroupName,
string expectedSubId,
Guid expectedTenantId,
string expectedLocation,
string expectedSkuFamily,
SkuName expectedSku,
bool expectedEnabledForDeployment,
bool expectedEnabledForTemplateDeployment,
bool expectedEnabledForDiskEncryption,
bool?expectedEnableSoftDelete,
AccessPolicyEntry[] expectedPolicies,
NetworkRuleSet networkRuleSet,
Dictionary <string, string> expectedTags)
{
ValidateVault(
vaultData,
expectedVaultName,
expectedResourceGroupName,
expectedSubId,
expectedTenantId,
expectedLocation,
expectedSkuFamily,
expectedSku,
expectedEnabledForDeployment,
expectedEnabledForTemplateDeployment,
expectedEnabledForDiskEncryption,
expectedEnableSoftDelete,
expectedPolicies,
expectedTags);
Assert.NotNull(vaultData.Properties.NetworkAcls);
Assert.AreEqual(networkRuleSet.DefaultAction, vaultData.Properties.NetworkAcls.DefaultAction);
Assert.AreEqual(networkRuleSet.Bypass, vaultData.Properties.NetworkAcls.Bypass);
Assert.True(vaultData.Properties.NetworkAcls.IpRules != null && vaultData.Properties.NetworkAcls.IpRules.Count == 2);
Assert.AreEqual(networkRuleSet.IpRules[0].Value, vaultData.Properties.NetworkAcls.IpRules[0].Value);
Assert.AreEqual(networkRuleSet.IpRules[1].Value, vaultData.Properties.NetworkAcls.IpRules[1].Value);
}
public VaultData ReadVault(Account acc)
{
var cmd = CreateQuery();
cmd.CommandText = "SELECT chestId, items FROM vaults WHERE accId=@accId;";
cmd.Parameters.AddWithValue("@accId", acc.AccountId);
using (var rdr = cmd.ExecuteReader())
{
if (rdr.HasRows)
{
VaultData ret = new VaultData() { Chests = new List<VaultChest>() };
while (rdr.Read())
{
ret.Chests.Add(new VaultChest()
{
ChestId = rdr.GetInt32("chestId"),
_Items = rdr.GetString("items")
});
}
return ret;
}
else
{
return new VaultData()
{
Chests = new List<VaultChest>()
};
}
}
}
/**
* Accept a received string of information from the server,
* and do something with it
*/
void ProcessReceivedData(string receivedJson)
{
if (receivedJson == "")
{
return;
}
Debug.Log("Received data: " + receivedJson);
//Convert json into object
VaultData fromNetworkData = JsonUtility.FromJson <VaultData>(receivedJson);
/*
* Handle the data:
*/
switch (fromNetworkData.iden)
{
//INIITIAL SETUP HANDSHAKE:
case VaultData.NetworkMessageT.HANDSHAKE:
Debug.Log("Network Handshake Complete");
//Update the connection UI:
text.text = "Connected";
//Send some information
foreach (var obj in this.registered.Values)
{
this.createMessage(obj.GetComponent <ActorAIStub> ().toPythonString());
}
break;
//INSTRUCTION TO CHANGE THE GAME WORLD:
case VaultData.NetworkMessageT.ACTION:
Debug.Log("Got an Action Header");
Debug.Log(String.Format("Payload: {0}", fromNetworkData.data));
Debug.Assert(fromNetworkData.hash == NetworkScript.CalculateHash(fromNetworkData.data));
this.fromServerQueue.Enqueue(fromNetworkData.data);
break;
//NOTIFICATION OF AI CYCLE / TURN COMPLETION:
case VaultData.NetworkMessageT.AI_COMPLETE:
Debug.Log("AI Finished, time to trigger actions");
break;
//INSTRUCTION TO RESEND CORRUPTED DATA
case VaultData.NetworkMessageT.RESEND:
Debug.Log("Hash Mismatch, Resend Data: " + fromNetworkData.hash);
break;
//MESSAGES THAT SHOULD ONLY BE SENT, NOT RECEIVED:
case VaultData.NetworkMessageT.INFO:
case VaultData.NetworkMessageT.AI_GO:
throw new Exception("Data or command passed in the wrong direction");
break;
//UPON QUIT OF GAME, SIGNAL SHUTDOWN OF SERVER
case VaultData.NetworkMessageT.QUIT:
text.text = "Disconnected";
closeSocket();
break;
default:
closeSocket();
break;
}
}
public async Task KeyVaultManagementVaultCreateUpdateDelete()
{
VaultProperties.EnableSoftDelete = null;
VaultCreateOrUpdateContent parameters = new VaultCreateOrUpdateContent(Location, VaultProperties);
parameters.Tags.InitializeFrom(Tags);
ArmOperation <VaultResource> rawVault = await VaultCollection.CreateOrUpdateAsync(WaitUntil.Completed, VaultName, parameters).ConfigureAwait(false);
VaultData createdVault = rawVault.Value.Data;
ValidateVault(createdVault,
VaultName,
ResGroupName,
TestEnvironment.SubscriptionId,
TenantIdGuid,
Location,
"A",
KeyVaultSkuName.Standard,
true,
true,
true,
true, // enableSoftDelete defaults to true
new[] { AccessPolicy },
VaultProperties.NetworkAcls,
Tags);
//Update
AccessPolicy.Permissions.Secrets.Clear();
AccessPolicy.Permissions.Secrets.Add(SecretPermission.Get);
AccessPolicy.Permissions.Secrets.Add(SecretPermission.Set);
(AccessPolicy.Permissions.Keys as ChangeTrackingList <KeyPermission>).Reset();
AccessPolicy.Permissions.Storage.Clear();
AccessPolicy.Permissions.Storage.Add(StoragePermission.Get);
AccessPolicy.Permissions.Storage.Add(StoragePermission.Regeneratekey);
createdVault.Properties.AccessPolicies.Clear();
createdVault.Properties.AccessPolicies.Add(AccessPolicy);
createdVault.Properties.Sku.Name = KeyVaultSkuName.Premium;
parameters = new VaultCreateOrUpdateContent(Location, createdVault.Properties);
parameters.Tags.InitializeFrom(Tags);
ArmOperation <VaultResource> rawUpdateVault = await VaultCollection.CreateOrUpdateAsync(WaitUntil.Completed, VaultName, parameters).ConfigureAwait(false);
VaultData updateVault = rawUpdateVault.Value.Data;
ValidateVault(updateVault,
VaultName,
ResGroupName,
TestEnvironment.SubscriptionId,
TenantIdGuid,
Location,
"A",
KeyVaultSkuName.Premium,
true,
true,
true,
true,
new[] { AccessPolicy },
VaultProperties.NetworkAcls,
Tags);
Response <VaultResource> rawRetrievedVault = await VaultCollection.GetAsync(VaultName);
VaultData retrievedVault = rawRetrievedVault.Value.Data;
ValidateVault(retrievedVault,
VaultName,
ResGroupName,
TestEnvironment.SubscriptionId,
TenantIdGuid,
Location,
"A",
KeyVaultSkuName.Premium,
true,
true,
true,
true,
new[] { AccessPolicy },
VaultProperties.NetworkAcls,
Tags);
// Delete
ArmOperation deleteVault = await rawRetrievedVault.Value.DeleteAsync(WaitUntil.Completed);
Assert.ThrowsAsync <RequestFailedException>(async() =>
{
await VaultCollection.GetAsync(VaultName);
});
}
