public void RoundtripSerialization2()
{
var program = new ProgramInfo(1, 1, "carbon", "carbon", new SemanticVersion(1, 1, 1));
var deployment = new DeploymentDetails(program, new[] {
ManagedResource.Host(Borg, id: "1"),
ManagedResource.Cluster(Borg, id: "2"),
ManagedResource.Environment(Borg, id: "3")
});
Assert.Equal(@"{
""program"": {
""id"": 1,
""version"": ""1.1.1""
},
""targets"": [
{
""resource"": ""borg:host\/1""
},
{
""resource"": ""borg:cluster\/2""
},
{
""resource"": ""borg:environment\/3""
}
]
}", JsonObject.FromObject(deployment).ToString());
}
public HostInfo(
long id,
long ownerId,
int locationId,
string[] addresses,
long environmentId,
long clusterId,
long imageId,
long machineTypeId,
ManagedResource resource,
HostType type = HostType.Virtual,
HostStatus status = HostStatus.Running)
{
Ensure.IsValidId(id);
Ensure.IsValidId(ownerId, nameof(ownerId));
Id = id;
OwnerId = ownerId;
Type = type;
Status = status;
Addresses = addresses;
ClusterId = clusterId;
EnvironmentId = environmentId;
LocationId = locationId;
ImageId = imageId;
MachineTypeId = machineTypeId;
ProviderId = resource.ProviderId;
ResourceId = resource.ResourceId;
}
public async Task <VolumeInfo> GetAsync(
ResourceProvider provider,
string resourceId,
IHost host = null)
{
Ensure.NotNull(resourceId, nameof(resourceId));
var volume = await volumeService.FindAsync(provider, resourceId);;
// If the volume isn't register, register it now...
if (volume == null)
{
var ec2Volume = await ec2.DescribeVolumeAsync(resourceId);;
var location = Locations.Get(provider, ec2Volume.AvailabilityZone);
var registerRequest = new RegisterVolumeRequest(
size: ByteSize.FromGiB(ec2Volume.Size),
ownerId: 1,
resource: ManagedResource.Volume(location, ec2Volume.VolumeId)
);
volume = await volumeService.RegisterAsync(registerRequest);;
}
return(volume);
}
private async Task <NetworkInfo> GetAsync(string vpcId)
{
var network = await networkService.FindAsync(Aws, vpcId);;
if (network == null)
{
var vpc = await ec2Client.DescribeVpcAsync(vpcId)
?? throw ResourceError.NotFound(Aws, ResourceTypes.Network, vpcId);
var region = Locations.Get(Aws, ec2Client.Region.Name);
var registerRequest = new RegisterNetworkRequest(
addressBlocks: new[] { vpc.CidrBlock },
resource: ManagedResource.Network(region, vpc.VpcId),
ownerId: 1
);
// TODO: Sync the subnets & security groups
// TODO: Support ipv6 address blocks
// Register the network with the platform
network = await networkService.RegisterAsync(registerRequest);;
}
return(network);
}
public async Task <SubnetInfo> GetSubnetAsync(ResourceProvider provider, string subnetId)
{
var subnet = await subnetService.FindAsync(provider, subnetId);;
if (subnet == null)
{
var awsSubnet = await ec2Client.DescribeSubnetAsync(subnetId)
?? throw ResourceError.NotFound(Aws, ResourceTypes.Subnet, subnetId);
var location = Locations.Get(Aws, awsSubnet.AvailabilityZone);
var network = await networkService.GetAsync(Aws, awsSubnet.VpcId);;
var createRequest = new RegisterSubnetRequest(
addressBlocks: new[] { awsSubnet.CidrBlock },
networkId: network.Id,
resource: ManagedResource.Subnet(location, awsSubnet.SubnetId)
);
// TODO: Include the ipv6 address blocks
// Register the subnet with the platform
subnet = await subnetService.RegisterAsync(createRequest);;
}
return(subnet);
}
private ManagedResource <resources.UITileSheetInfo, TileSheet> Preload(
out TileSheet tileSheet,
string name,
bool isFont,
float lineHeight = float.NaN,
float charSpacing = float.NaN,
float lineOffset = float.NaN)
{
var resource = ManagedResource <TileSheet> .Create(new resources.UITileSheetInfo(name, isFont));
var entity = world.CreateEntity();
entity.Set(resource);
entity.Disable();
tileSheet = entity.Get <TileSheet>();
if (float.IsFinite(lineHeight))
{
tileSheet.LineHeight = lineHeight;
}
if (float.IsFinite(charSpacing))
{
tileSheet.CharSpacing = charSpacing;
}
if (float.IsFinite(lineOffset))
{
tileSheet.LineOffset = lineOffset;
}
return(resource);
}
// Register a managed resource via a project asset.
public static void Register <T> (this ManagedResource <T> resource, T asset, long id = 0) where T : UnityEngine.Object
{
// Format the path to the asset so it starts at the root Resources directory and drops the extension.
string assetPath = AssetDatabase.GetAssetPath(asset).Replace("Assets/Resources/", "");
string extension = Path.GetExtension(assetPath);
if (!string.IsNullOrEmpty(extension))
{
assetPath = assetPath.Replace(extension, "");
}
// Default to collection index -1.
int collectionIndex = -1;
// If the asset is a Sprite, check if it is a part of a collection and determine its index.
Sprite sprite = asset as Sprite;
if (sprite != null)
{
Object[] sprites = Resources.LoadAll(assetPath);
for (int i = 0; i < sprites.Length; i++)
{
if (sprites [i].GetInstanceID() == sprite.GetInstanceID())
{
collectionIndex = i;
}
}
}
// Serialize the resource path.
resource.SetResourcePath(assetPath, collectionIndex, id);
}
public RegisterHostRequest(
long ownerId,
string[] addresses,
ILocation location,
ICluster cluster,
IImage image,
IProgram program,
IMachineType machineType,
ManagedResource resource,
HostStatus status = HostStatus.Pending,
HostType type = HostType.Virtual)
{
Ensure.IsValidId(ownerId, nameof(ownerId));
Ensure.NotNull(cluster, nameof(cluster));
Ensure.NotNull(location, nameof(location));
Ensure.NotNull(image, nameof(image));
Ensure.NotNull(machineType, nameof(machineType));
OwnerId = ownerId;
Addresses = addresses;
LocationId = location.Id;
EnvironmentId = cluster.EnvironmentId;
ClusterId = cluster.Id;
ImageId = image.Id;
MachineType = new MachineTypeDescriptor {
Id = machineType.Id,
Name = machineType.Name
};
Status = status;
Resource = resource;
Type = type;
}
public PlayerTriggers(ITagContainer diContainer)
{
world = diContainer.GetTag <DefaultEcs.World>();
playerControls = diContainer.GetTag <PlayerControls>();
zzContainer = diContainer.GetTag <IZanzarahContainer>();
zzContainer.OnMouseDown += HandleMouseDown;
var game = diContainer.GetTag <Game>();
cameraLocation = diContainer.GetTag <rendering.Camera>().Location;
playerLocationLazy = new Lazy <Location>(() => game.PlayerEntity.Get <Location>());
npcMarker = world.CreateEntity();
npcMarker.Set(new Location());
npcMarker.Set(new components.behaviour.Rotate(Vector3.UnitY, 90f));
npcMarker.Set(ManagedResource <ClumpBuffers> .Create(
new resources.ClumpInfo(resources.ClumpType.Model, "marker.dff")));
ModelLoader.LoadMaterialsFor(npcMarker,
zzio.scn.FOModelRenderType.Solid,
zzio.IColor.Green,
new zzio.SurfaceProperties(1f, 1f, 1f));
var materials = npcMarker.Get <List <materials.BaseModelInstancedMaterial> >();
foreach (var material in materials)
{
material.Uniforms.Ref.vertexColorFactor = 1f;
}
}
public UIPreloader(ITagContainer diContainer)
{
world = diContainer.GetTag <DefaultEcs.World>();
mappedDb = diContainer.GetTag <zzio.db.MappedDB>();
Btn000 = Preload(out var tsBtn000, "btn000", isFont: false);
Btn001 = Preload(out var tsBtn001, "btn001", isFont: false);
Btn002 = Preload(out var tsBtn002, "btn002", isFont: false);
Sld000 = Preload(out var tsSld000, "sld000", isFont: false);
Tit000 = Preload(out var tsTit000, "tit000", isFont: false);
Cur000 = Preload(out var tsCur000, "cur000", isFont: false);
Dnd000 = Preload(out var tsDnd000, "dnd000", isFont: false);
Wiz000 = Preload(out var tsWiz000, "wiz000", isFont: false);
Itm000 = Preload(out var tsItm000, "itm000", isFont: false);
Spl000 = Preload(out var tsSpl000, "spl000", isFont: false);
Lne000 = Preload(out var tsLne000, "lne000", isFont: false);
Fnt000 = Preload(out var tsFnt000, "fnt000", isFont: true, lineHeight: 14f, charSpacing: 1f);
Fnt001 = Preload(out var tsFnt001, "fnt001", isFont: true, charSpacing: 1f);
Fnt002 = Preload(out var tsFnt002, "fnt002", isFont: true, lineHeight: 17f, charSpacing: 1f, lineOffset: 2f);
Fnt003 = Preload(out var tsFnt003, "fnt003", isFont: true, lineHeight: 14f, charSpacing: 1f);
Fnt004 = Preload(out var tsFnt004, "fnt004", isFont: true, lineHeight: 14f, charSpacing: 1f);
Fsp000 = Preload(out var tsFsp000, "fsp000", isFont: true);
Inf000 = Preload(out var tsInf000, "inf000", isFont: false);
Log000 = Preload(out var tsLog000, "log000", isFont: false);
Cls000 = Preload(out var tsCls000, "cls000", isFont: false);
Cls001 = Preload(out var tsCls001, "cls001", isFont: false);
Map000 = Preload(out var tsMap000, "map000", isFont: false);
tsFnt000.Alternatives.Add(tsFnt001);
tsFnt000.Alternatives.Add(tsFnt002);
tsFnt000.Alternatives.Add(tsFsp000);
tsFnt000.Alternatives.Add(tsItm000);
tsFnt000.Alternatives.Add(tsCls000);
tsFnt000.Alternatives.Add(tsFnt003);
tsFnt000.Alternatives.Add(tsLog000);
tsFnt000.Alternatives.Add(tsCls001);
tsFnt000.Alternatives.Add(tsFnt004);
tsFnt001.Alternatives.Add(tsFnt002);
tsFnt001.Alternatives.Add(tsInf000);
tsFnt001.Alternatives.Add(tsFnt000);
tsFnt002.Alternatives.Add(tsFnt001);
tsFnt002.Alternatives.Add(tsInf000);
tsFnt002.Alternatives.Add(tsFsp000);
tsFnt002.Alternatives.Add(tsItm000);
tsFnt002.Alternatives.Add(tsCls000);
tsFnt002.Alternatives.Add(tsCls001);
tsFnt003.Alternatives.Add(tsFnt001);
tsFnt003.Alternatives.Add(tsFnt002);
tsFnt003.Alternatives.Add(tsFsp000);
tsFnt003.Alternatives.Add(tsItm000);
tsFnt003.Alternatives.Add(tsFnt000);
tsFnt003.Alternatives.Add(tsFnt000);
tsFnt003.Alternatives.Add(tsLog000);
tsFnt003.Alternatives.Add(tsCls001);
tsFnt003.Alternatives.Add(tsFnt004);
}
public HealthCheck(
long id,
long ownerId,
Uri url,
ManagedResource resource)
: this(id, ownerId, url.Host, url.AbsolutePath, url.Port, NetworkProtocal.TCP, resource)
{
}
public Router(long id, string name, ManagedResource resource)
{
Id = id;
Name = name ?? throw new ArgumentNullException(nameof(name));
ProviderId = resource.ProviderId;
LocationId = resource.LocationId;
ResourceId = resource.ResourceId;
}
public RegisterVolumeRequest(long ownerId, ByteSize size, ManagedResource resource)
{
Ensure.IsValidId(ownerId, nameof(ownerId));
OwnerId = ownerId;
Size = size;
Resource = resource;
}
public RegisterLoadBalancer(long ownerId, string name, ManagedResource resource)
{
Ensure.IsValidId(ownerId, nameof(ownerId));
Ensure.NotNullOrEmpty(nameof(name), name);
Name = name;
OwnerId = ownerId;
Resource = resource;
}
public RegisterNetworkRequest(
string[] addressBlocks,
long ownerId,
ManagedResource resource)
{
AddressBlocks = addressBlocks ?? throw new ArgumentNullException(nameof(addressBlocks));
OwnerId = ownerId;
Resource = resource;
}
public NetworkSecurityGroup(long id, string name, ManagedResource resource)
{
Ensure.IsValidId(id);
Ensure.NotNullOrEmpty(name, nameof(name));
Id = id;
Name = name;
ProviderId = resource.ProviderId;
ResourceId = resource.ResourceId;
}
public RegisterSubnetRequest(
string[] addressBlocks,
long networkId,
ManagedResource resource)
{
Ensure.IsValidId(networkId, nameof(networkId));
AddressBlocks = addressBlocks ?? throw new ArgumentNullException(nameof(addressBlocks));
NetworkId = networkId;
Resource = resource;
}
/// <summary>
/// Serializes all data within the provided resources.
/// </summary>
/// <param name="obj">Resource to serialize.</param>
/// <returns>Object containing serialized data.</returns>
public static SerializedObject Create(ManagedResource obj)
{
if (obj == null)
{
return(null);
}
IntPtr resourcePtr = obj.GetCachedPtr();
return(Internal_CreateResource(resourcePtr));
}
public RegisterNetworkInterfaceRequest(
MacAddress mac,
long subnetId,
long[] securityGroupIds,
ManagedResource resource)
{
Mac = mac;
SubnetId = subnetId;
SecurityGroupIds = securityGroupIds;
Resource = resource;
}
public RegisterNetworkSecurityGroupRequest(
string name,
long networkId,
ManagedResource resource)
{
Ensure.NotNull(name, nameof(name));
Ensure.IsValidId(networkId, nameof(networkId));
Name = name;
NetworkId = networkId;
Resource = resource;
}
public DatabaseCluster(long id, string name, ManagedResource resource, JsonObject properties = null)
{
Ensure.IsValidId(id, nameof(id));
Ensure.NotNullOrEmpty(name, nameof(name));
Id = id;
Name = name;
ResourceId = resource.ResourceId;
ProviderId = resource.ProviderId;
LocationId = resource.LocationId;
Properties = properties ?? new JsonObject();
}
// 1 | aws:vpc1
public async Task <NetworkInfo> GetAsync(string name)
{
if (long.TryParse(name, out var id))
{
return(await GetAsync(id));
}
var(provider, resourceId) = ResourceName.Parse(name);
return(await FindAsync(provider, resourceId)
?? throw ResourceError.NotFound(ManagedResource.Network(provider, name)));
}
public RegisterDatabaseInstanceRequest(
long databaseId,
ManagedResource resource,
int priority = 1,
DatabaseFlags flags = DatabaseFlags.Primary)
{
Ensure.IsValidId(databaseId, nameof(databaseId));
DatabaseId = databaseId;
Resource = resource;
Priority = priority;
Flags = flags;
}
public RegisterDatabaseClusterRequest(
string name,
ManagedResource resource,
RegisterDatabaseInstanceRequest[] instances,
RegisterDatabaseEndpointRequest[] endpoints)
{
Ensure.NotNullOrEmpty(name, nameof(name));
Name = name;
Resource = resource;
Instances = instances;
Endpoints = endpoints;
}
public async Task <VolumeInfo> GetAsync(string name)
{
Ensure.NotNullOrEmpty(name, nameof(name));
if (long.TryParse(name, out var id))
{
return(await GetAsync(id));
}
var(provider, resourceId) = ResourceName.Parse(name);
return(await FindAsync(provider, resourceId)
?? throw ResourceError.NotFound(ManagedResource.Volume(provider, name)));
}
public SubnetInfo(
long id,
string[] addressBlocks,
ManagedResource resource)
{
Ensure.IsValidId(id);
Ensure.NotNull(addressBlocks, nameof(addressBlocks));
Id = id;
AddressBlocks = addressBlocks;
ProviderId = resource.ProviderId;
LocationId = resource.LocationId;
ResourceId = resource.ResourceId;
}
public RegisterBucketRequest(long ownerId, string name, ManagedResource resource)
{
Ensure.IsValidId(ownerId, nameof(ownerId));
Ensure.NotNullOrEmpty(name, nameof(name));
if (name.Length > 63)
{
throw new ArgumentException("Must be 63 characters or fewer", nameof(name));
}
Name = name;
Resource = resource;
OwnerId = ownerId;
}
public DatabaseInstance(
long id,
long clusterId,
DatabaseFlags flags,
int priority,
ManagedResource resource)
{
Id = id;
Flags = flags;
ClusterId = clusterId;
Priority = priority;
ProviderId = resource.ProviderId;
LocationId = resource.LocationId;
ResourceId = resource.ResourceId;
}
public RegisterImageRequest(
long ownerId,
string name,
ManagedResource resource,
ImageType type = ImageType.Machine,
JsonObject properties = null)
{
Ensure.IsValidId(ownerId, nameof(ownerId));
Ensure.NotNullOrEmpty(name, nameof(name));
Name = name;
OwnerId = ownerId;
Resource = resource;
Type = type;
Properties = properties;
}
public NetworkAddress(
long id,
IPAddress address,
ManagedResource resource,
long?hostId = null,
long?networkInterfaceId = null)
{
Ensure.IsValidId(id);
Ensure.NotNull(address, nameof(address));
Id = id;
Address = address;
ProviderId = resource.ProviderId;
ResourceId = resource.ResourceId;
HostId = hostId;
NetworkInterfaceId = networkInterfaceId;
}
