Migrating cradle server

aurora-cradle-sharp/AuroraCradle/Src/Augments/Party.cs

@@ -0,0 +1,9 @@
+using Aurora.Cursor;
+
+namespace Aurora.Services.Signal
+{
+    public partial class Party : ICursorObject
+    {
+    }
+}
+

aurora-cradle-sharp/AuroraCradle/Src/Cursor/Cursor.cs

@@ -0,0 +1,126 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+#nullable enable
+namespace Aurora.Cursor
+{
+    public enum SortDirection
+    {
+        Asc,
+        Desc,
+    }
+
+    public class Cursor<T> where T : ICursorObject
+    {
+        private CursorList<T> _list;
+
+        private string? _previousPageToken;
+        private string? _nextPageToken;
+        private int _pageSize;
+        private Func<KeyValuePair<string, T>, string> _sortDelgate;
+        private SortDirection _direction;
+        public Cursor(ref CursorList<T> list)
+        {
+            this._list = list;
+            this._previousPageToken = string.Empty;
+            this._nextPageToken = string.Empty;
+            this._pageSize = 10;
+            this._sortDelgate = delegate (KeyValuePair<string, T> item)
+            {
+                return item.Key;
+            };
+        }
+
+        public CursorResult<T> GetNextPage()
+        {
+            if (this._pageSize < 0)
+            {
+                throw new InvalidOperationException("Page Size must be greater than zero");
+            }
+            List<KeyValuePair<string, T>> tmpList;
+
+            // Sort reference list
+            if (this._direction == SortDirection.Desc)
+            {
+                tmpList = this._list.OrderByDescending(this._sortDelgate).ToList();
+
+            }
+            else
+            {
+                tmpList = this._list.OrderBy(this._sortDelgate).ToList();
+            }
+
+            if (tmpList == null)
+            {
+                throw new System.NullReferenceException();
+            }
+
+            int startIdx = 0;
+            if (!string.IsNullOrEmpty(this._nextPageToken))
+            {
+                // TODO find another way to index into the list that's not a regular array search
+                startIdx = tmpList.FindIndex(item => item.Key == this._nextPageToken) + 1;
+            }
+
+            int adjustedSize = this._pageSize;
+            if (startIdx + this._pageSize > tmpList.Count)
+            {
+                adjustedSize = this._pageSize - ((startIdx + _pageSize) - tmpList.Count);
+            }
+
+
+            List<KeyValuePair<string, T>> selection = new List<KeyValuePair<string, T>>();
+            if (adjustedSize != 0)
+            {
+                selection = tmpList.GetRange(startIdx, adjustedSize);
+            }
+
+            return new CursorResult<T>
+            {
+                NextPageToken = this._pageSize == selection.Count ? selection[selection.Count - 1].Key : string.Empty,
+                PrevPageToken = string.Empty,
+                Count = this._list.Count,
+                Result = selection.ConvertAll(item => item.Value)
+            };
+        }
+
+        public CursorResult<T> GetPreviousPage()
+        {
+            throw new NotImplementedException();
+        }
+
+        public Cursor<T> WithNextPageToken(string nextPageToken)
+        {
+            this._nextPageToken = nextPageToken;
+            return this;
+        }
+
+        public Cursor<T> WithPreviousPageToken(string prevPageToken)
+        {
+            this._previousPageToken = prevPageToken;
+            return this;
+        }
+
+        public Cursor<T> WithSort(Func<KeyValuePair<string, T>, string> sortDelegate, SortDirection direction)
+        {
+            this._sortDelgate = sortDelegate;
+            this._direction = direction;
+            return this;
+        }
+
+        public Cursor<T> WithSort(string key, SortDirection direction)
+        {
+            this._sortDelgate = (item) => key;
+            this._direction = direction;
+            return this;
+        }
+
+        public Cursor<T> WithSize(int size)
+        {
+            this._pageSize = size;
+            return this;
+        }
+    }
+
+}

aurora-cradle-sharp/AuroraCradle/Src/Cursor/CursorList.cs

@@ -0,0 +1,37 @@
+using System.Collections.Generic;
+using System.Collections;
+using System;
+using System.Linq;
+using Aurora.Utils;
+
+#nullable enable
+namespace Aurora.Cursor
+{
+
+    public class CursorList<T> : SortedList<string, T> where T : ICursorObject
+    {
+
+        public CursorList()
+        {
+        }
+
+        public CursorList<T> Add(T item)
+        {
+            string id = item.Id;
+            if (item.Id == null)
+            {
+                id = HashUtil.GetHash(new string[] { item.GetHashCode().ToString() }).ToString();
+                item.Id = id;
+            }
+            bool res = this.TryAdd(id, item);
+
+            if (res == false)
+            {
+                throw new System.Exception("Failed to add item to cursor list");
+            }
+            return this;
+        }
+
+
+    }
+}

aurora-cradle-sharp/AuroraCradle/Src/Cursor/CursorObject.cs

@@ -0,0 +1,9 @@
+using System.Collections.Generic;
+
+namespace Aurora.Cursor
+{
+    public interface ICursorObject
+    {
+        string Id { get; set; }
+    }
+}

aurora-cradle-sharp/AuroraCradle/Src/Cursor/CursorResult.cs

@@ -0,0 +1,25 @@
+using System.Collections.Generic;
+
+namespace Aurora.Cursor
+{
+    public class CursorResult<T>
+    {
+        public CursorResult()
+        {
+            Result = new List<T>();
+        }
+
+        public CursorResult(CursorResult<T> cpy)
+        {
+            NextPageToken = cpy.NextPageToken;
+            PrevPageToken = cpy.PrevPageToken;
+            Result = cpy.Result;
+            Count = cpy.Count;
+        }
+
+        public string NextPageToken { get; set; }
+        public string PrevPageToken { get; set; }
+        public List<T> Result { get; set; }
+        public int Count { get; set; }
+    }
+}

aurora-cradle-sharp/AuroraCradle/Src/Program.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.Hosting;
+
+namespace Aurora
+{
+    public class Program
+    {
+        public static void Main(string[] args)
+        {
+            CreateHostBuilder(args).Build().Run();
+        }
+
+        // Additional configuration is required to successfully run gRPC on macOS.
+        // For instructions on how to configure Kestrel and gRPC clients on macOS, visit https://go.microsoft.com/fwlink/?linkid=2099682
+        public static IHostBuilder CreateHostBuilder(string[] args) =>
+            Host.CreateDefaultBuilder(args)
+                .ConfigureWebHostDefaults(webBuilder =>
+                {
+                    webBuilder.UseStartup<Startup>();
+                });
+    }
+}

aurora-cradle-sharp/AuroraCradle/Src/Protos/signal.proto

@@ -0,0 +1,167 @@
+syntax = "proto3";
+
+option csharp_namespace = "Aurora.Services.Signal";
+
+package signal;
+
+
+import "google/protobuf/timestamp.proto";
+import "google/protobuf/field_mask.proto";
+import "google/protobuf/empty.proto";
+
+
+service Signal {
+    //**************
+    //Party Resource
+    //**************
+    //Get Party
+    rpc ListParties(ListPartiesRequest) returns (ListPartiesResponse);
+
+    rpc GetParty(GetPartyRequest) returns (Party);
+
+    rpc UpdateParty(UpdatePartyRequest) returns (Party);
+
+    rpc CreateParty(CreatePartyRequest) returns (Party);
+
+    rpc DeleteParty(DeletePartyRequest) returns (google.protobuf.Empty);
+
+
+    //***************************
+    //EventSubscriptions Resource
+    //***************************
+    //List
+    rpc ListEventSubscriptions(ListEventSubscriptionsRequest) returns (ListEventSubscriptionsResponse);
+
+    //Create
+    rpc SubscribeToEvent(EventSubscriptionRequest) returns (EventSubscription);
+    
+    //Delete
+    rpc DeleteEventSubscription(DeleteEventSubscriptionRequest) returns (google.protobuf.Empty);
+
+    //CUSTOM: Create EventSubscription List
+    rpc SubscribeToEvents(EventSubscriptionListRequest) returns (EventSubscriptionListResponse);
+
+    //CUSTOM: Delete all
+    rpc DeleteAllEventSubscriptions(DeleteAllEventSubscriptionsRequest) returns (google.protobuf.Empty);
+    
+    //*****
+    //Event 
+    //*****
+    //Get
+    rpc GetEventStream(GetEventsRequest) returns (stream BaseEvent) {};
+}
+
+message Party {
+    //The resource name of the party
+    string name = 1;
+    string id = 2;
+    string display_name = 3;
+    string description = 4;
+    string host_ip = 5;
+    google.protobuf.Timestamp created_on = 6;
+}
+
+message PartyListItem {
+    string name = 1;
+    string id = 2;
+}
+
+message ListPartiesRequest {
+    int32 page_size = 1;
+    string page_token = 2;
+    string order_by = 3;
+    SortDirection order_direction = 4;
+}
+
+enum SortDirection {
+    Asc = 0;
+    Desc = 1;
+}
+
+message ListPartiesResponse {
+    repeated PartyListItem parties = 1;
+    string next_page_token = 2;
+}
+
+message GetPartyRequest {
+    string party_id = 1;
+}
+
+message CreatePartyRequest {
+    string party_id = 1;
+    Party party = 2;
+}
+
+message DeletePartyRequest {
+    string party_id = 1;
+}
+
+message UpdatePartyRequest {
+    Party party = 1;
+    google.protobuf.FieldMask update_mask = 2;
+}
+
+/* Event Types */
+enum EventType {
+    NewPartiesAvailable = 0;
+}
+
+message NewPartiesAvailableEvent {
+}
+
+message BaseEvent {
+    //Resource name of the event ?
+    string name = 1;
+    EventType event_type = 2;    
+    oneof derivedEvent {
+        NewPartiesAvailableEvent new_parties_available_event = 3;
+    }
+}
+
+message EventSubscription {
+    EventType type = 2;
+}
+
+message ListEventSubscriptionsRequest {
+    //Resource name of parent to the subscription list (The member)
+    string parent = 1;
+    int32 page_size = 2;
+    string page_token = 3;
+}
+
+message ListEventSubscriptionsResponse {
+    repeated EventSubscription subscriptions = 1;
+    string next_page_token = 2;
+}
+
+message EventSubscriptionRequest {
+    //Resource name of the parent to the subscription list (The member)
+    string parent = 1;
+    EventSubscription event_subscription = 2;
+}
+
+message DeleteEventSubscriptionRequest {
+    //Resource name of the subscription to delete
+    string parent = 1;
+    EventType type = 2;
+}
+
+message EventSubscriptionListRequest {
+    //Resource name of the parent to the subscription list (The member)
+    string parent = 1;
+    repeated EventSubscription event_subscriptions = 2;
+}
+
+message EventSubscriptionListResponse {
+    repeated EventSubscription event_subscriptions = 1;
+}
+
+message DeleteAllEventSubscriptionsRequest {
+    //Resource name of the parent to the subscription list (the member)
+    string parent = 1;
+}
+
+message GetEventsRequest {
+    //Resource name of the parent to the event stream (the member)
+    string parent = 1;
+}

aurora-cradle-sharp/AuroraCradle/Src/Services/Signal/Events.cs

@@ -0,0 +1,7 @@
+namespace Aurora.Services.Signal
+{
+    public partial class SignalService : Signal.SignalBase
+    {
+
+    }
+}

aurora-cradle-sharp/AuroraCradle/Src/Services/Signal/Party.cs

@@ -0,0 +1,79 @@
+using System.Threading.Tasks;
+using Google.Protobuf.WellKnownTypes;
+using Grpc.Core;
+using Aurora.Cursor;
+using Microsoft.Extensions.Logging;
+
+namespace Aurora.Services.Signal
+{
+    public partial class SignalService : Signal.SignalBase
+    {
+        private CursorList<Party> _partyList;
+
+        public override Task<Party> CreateParty(CreatePartyRequest request, ServerCallContext context)
+        {
+            Party party = new Party(request.Party);
+            _partyList.Add(party);
+
+            this._logger.LogInformation(string.Format("Added party with name: ${0} to parties", party.Name));
+
+            return Task.FromResult(party);
+        }
+
+        public override Task<Empty> DeleteParty(DeletePartyRequest request, ServerCallContext context)
+        {
+            if (this._partyList.ContainsKey(request.PartyId))
+            {
+                this._partyList.Remove(request.PartyId);
+            }
+
+            this._logger.LogInformation(string.Format("Deleted party with id: ${0} to parties", request.PartyId));
+            return Task.FromResult(new Empty());
+        }
+
+        public override Task<ListPartiesResponse> ListParties(ListPartiesRequest request, ServerCallContext context)
+        {
+            Cursor<Party> cursor = new Cursor<Party>(ref this._partyList);
+
+            Aurora.Cursor.SortDirection direction = Aurora.Cursor.SortDirection.Asc;
+            if (request.OrderDirection == SortDirection.Desc)
+            {
+                direction = Aurora.Cursor.SortDirection.Desc;
+            }
+
+            CursorResult<Party> res = cursor
+                .WithSort(request.OrderBy, direction)
+                .WithNextPageToken(request.PageToken)
+                .WithSize(request.PageSize)
+                .GetNextPage();
+
+            ListPartiesResponse response = new ListPartiesResponse()
+            {
+                NextPageToken = res.NextPageToken
+            };
+            response.Parties.AddRange(res.Result.ConvertAll(party => new PartyListItem()
+            {
+                Name = party.Name,
+                Id = party.Id
+            }));
+            return Task.FromResult(response);
+        }
+
+        public override Task<Party> GetParty(GetPartyRequest request, ServerCallContext context)
+        {
+            Party party = new Party();
+
+            if (this._partyList.ContainsKey(request.PartyId))
+            {
+                this._partyList.TryGetValue(request.PartyId, out party);
+            }
+
+            return Task.FromResult(party);
+        }
+
+        public override Task<Party> UpdateParty(UpdatePartyRequest request, ServerCallContext context)
+        {
+            throw new System.NotImplementedException();
+        }
+    }
+}

aurora-cradle-sharp/AuroraCradle/Src/Services/Signal/SignalService.cs

@@ -0,0 +1,17 @@
+using Microsoft.Extensions.Logging;
+using Aurora.Cursor;
+
+namespace Aurora.Services.Signal
+{
+    public partial class SignalService : Signal.SignalBase
+    {
+        private readonly ILogger<SignalService> _logger;
+
+        public SignalService(ILogger<SignalService> logger)
+        {
+            _logger = logger;
+            this._partyList = new CursorList<Party>();
+        }
+
+    }
+}

aurora-cradle-sharp/AuroraCradle/Src/Startup.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Aurora.Services.Signal;
+
+namespace Aurora
+{
+    public class Startup
+    {
+        // This method gets called by the runtime. Use this method to add services to the container.
+        // For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
+        public void ConfigureServices(IServiceCollection services)
+        {
+            services.AddGrpc();
+            services.AddGrpcReflection();
+        }
+
+        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
+        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
+        {
+            if (env.IsDevelopment())
+            {
+                app.UseDeveloperExceptionPage();
+
+            }
+
+            app.UseRouting();
+
+            app.UseEndpoints(endpoints =>
+            {
+                endpoints.MapGrpcService<SignalService>();
+
+                if (env.IsDevelopment())
+                {
+                    endpoints.MapGrpcReflectionService();
+                }
+                endpoints.MapGet("/", async context =>
+                {
+                    await context.Response.WriteAsync("Communication with gRPC endpoints must be made through a gRPC client. To learn how to create a client, visit: https://go.microsoft.com/fwlink/?linkid=2086909");
+                });
+            });
+        }
+    }
+}

aurora-cradle-sharp/AuroraCradle/Src/Utils/HashUtil.cs

@@ -0,0 +1,25 @@
+using System.Security.Cryptography;
+using System.Text;
+using System;
+
+namespace Aurora.Utils
+{
+    public class HashUtil
+    {
+        public static Guid GetHash(string[] inputs)
+        {
+            string input = "";
+            foreach (string str in inputs)
+            {
+                input += str;
+            }
+
+            byte[] stringbytes = Encoding.UTF8.GetBytes(input);
+            byte[] hashedBytes = new System.Security.Cryptography
+                .SHA1CryptoServiceProvider()
+                .ComputeHash(stringbytes);
+            Array.Resize(ref hashedBytes, 16);
+            return new Guid(hashedBytes);
+        }
+    }
+}

aurora-cradle-sharp/AuroraCradle/appsettings.Development.json

@@ -0,0 +1,10 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Debug",
+      "System": "Information",
+      "Grpc": "Information",
+      "Microsoft": "Information"
+    }
+  }
+}

aurora-cradle-sharp/AuroraCradle/appsettings.json

@@ -0,0 +1,15 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft": "Warning",
+      "Microsoft.Hosting.Lifetime": "Information"
+    }
+  },
+  "AllowedHosts": "*",
+  "Kestrel": {
+    "EndpointDefaults": {
+      "Protocols": "Http1"
+    }
+  }
+}

aurora-cradle-sharp/AuroraCradle/aurora-cradle-sharp.csproj

@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Protobuf Include="Src\Protos\signal.proto" GrpcServices="Server" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Grpc.AspNetCore" Version="2.27.0" />
+    <PackageReference Include="Grpc.AspNetCore.Server.Reflection" Version="2.35.0" />
+  </ItemGroup>
+
+</Project>