+Download bytes support (for storage files) - version 0.2.0

Author: HanzaRu

.icon.png

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2015, Unity Technologies
+
+Copyright (c) 2020 Game Workstore
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

LICENSE.md

@@ -0,0 +1,71 @@
+# Async Network Engine
+
+Unity http requests made easy to interoperability with Go Lang + Google Protobuf functions!
+
+Supported Cloud Functions:
+- Google Cloud Functions
+- Amazon Web Services Lambdas
+
+Use at your own risk!
+
+# How to install
+
+At package.json, add these 3 lines of code:
+```json
+"com.gameworkstore.asyncnetworkengine": "git://github.com/GameWorkstore/async-network-engine.git",
+"com.gameworkstore.googleprotobufunity": "git://github.com/GameWorkstore/google-protobuf-unity.git",
+"com.gameworkstore.patterns": "git://github.com/GameWorkstore/patterns.git"
+```
+
+And wait for unity to download and compile the package.
+
+for update package for a newer version, install UpmGitExtension and update on [ Window > Package Manager ]!
+> https://github.com/mob-sakai/UpmGitExtension
+
+# Usage Examples
+
+You can find usage examples on Assets/Tests/ folder, for each cloud.
+
+## Uploading to Google Cloud Functions
+
+on upmsync, the job 'upload_gcp' illustrates a possible way to upload your functions into GCP.
+Requires a service account to enable it to upload.
+
+## Uploading to Amazon Web Services
+
+on upmsync.yaml, the job 'upload_aws' illustrates a possible way to upload your functions into AWS.
+Requires a service account to enable it to upload.
+> You need to set the template 'cloudformation_function.yaml' public in your bucket repository to enable AWS::Stack to read from it.
+
+# Implementation
+
+## GCP Troubleshoot
+
+> My function is returning ErrorProtocol for any input.
+if you don't give access public for your function it might fail
+
+## AWS Troubleshoot
+> CloudFormation is returning errors
+
+Verify all variables, !Ref and links, you might be forgetting something. CloudFormations is very sensitive to linkage errors.
+
+> My lambda is returning error 500 Internal Server error.
+If you are receiving this and error object is returning null, it might be a bad configuration causing your lambda to not run.
+Verify if you function is running by adding a fmt.Println("test") at main() function to ensure the function is starting.
+Some issues that may prevent the start of function:
+- The functions ins't at correct path when extracted from the zip.
+- The function package name isn't main where main() function is declared.
+- lambda.Start() is never begin called to initialize the function.
+- The function is crashing upon initialization
+
+If the function is working normally, them you might receive error 500 - ErrorInternalServer with AWSError, when specified by the programmer.
+
+# Contributions
+
+If you are using this library and want to submit a change, go ahead! Overall, this project accepts contributions if:
+- Is a bug fix;
+- Or, is a generalization of a well-known issue;
+- Or is performance improvement;
+- Or is an improvement to already supported feature.
+
+Also, you can donate to allow us to drink coffee while we improve it for you!

LICENSE.md.meta

@@ -0,0 +1,222 @@
+using Google.Protobuf;
+using GameWorkstore.Patterns;
+using System;
+using System.Collections;
+using System.Text;
+using UnityEngine.Networking;
+using System.Collections.Generic;
+
+namespace GameWorkstore.AsyncNetworkEngine
+{
+    public enum CloudProvider
+    {
+        GCP = 0,
+        AWS = 1
+    }
+
+    public static class AsyncNetworkEngineMap
+    {
+        internal static bool IsSingleCloud = true;
+        internal static CloudProvider SingleCloudProvider = CloudProvider.AWS;
+        internal static Dictionary<string, CloudProvider> MapCloudProvider = null;
+
+        /// <summary>
+        /// Setup a single cloud provider for all functions.
+        /// </summary>
+        /// <param name="cloudProvider">Target cloud provider implementation.</param>
+        public static void SetupCloud(CloudProvider cloudProvider)
+        {
+            IsSingleCloud = true;
+            SingleCloudProvider = cloudProvider;
+        }
+
+        /// <summary>
+        /// Setup a multi cloud provider for all functions.
+        /// </summary>
+        /// <param name="mapCloudProvider">Maps base url to cloud provider. Use the lowest possible string to differentiate clouds.</param>
+        public static void SetupCloudMap(Dictionary<string, CloudProvider> mapCloudProvider)
+        {
+            IsSingleCloud = false;
+            MapCloudProvider = mapCloudProvider;
+        }
+    }
+
+    public static class AsyncNetworkEngine
+    {
+        private static EventService _eventService = null;
+
+        public static void Download(string uri,Action<Transmission,byte[]> result)
+        {
+            if (_eventService == null) _eventService = ServiceProvider.GetService<EventService>();
+            _eventService.StartCoroutine(SendRequest(uri, result));
+        }
+
+        public static IEnumerator SendRequest(string uri, Action<Transmission, byte[]> result)
+        {
+            using var rqt = UnityWebRequest.Get(uri);
+            yield return rqt.SendWebRequest();
+
+            switch(rqt.result){
+                case UnityWebRequest.Result.ConnectionError:
+                    Return(Transmission.ErrorConnection, null, result);
+                    break;
+                case UnityWebRequest.Result.Success:
+                    HandleSuccess(rqt,result);
+                    break;
+            }
+        }
+
+        private static void HandleSuccess(UnityWebRequest rqt, Action<Transmission, byte[]> result)
+        {
+            if (rqt.downloadHandler.data == null)
+            {
+                Return(Transmission.ErrorNoData, null, result);
+                return;
+            }
+            if (rqt.downloadHandler.data.Length <= 0)
+            {
+                Return(Transmission.ErrorNoData, null, result);
+                return;
+            }
+            Return(Transmission.Success, rqt.downloadHandler.data, result);
+        }
+
+        private static void Return(Transmission result, byte[] data, Action<Transmission, byte[]> callback)
+        {
+            callback?.Invoke(result,data);
+        }
+    }
+
+    /// <summary>
+    /// Implements a UnityRequest for google protobuf web functions.
+    /// </summary>
+    /// <typeparam name="TR">Request</typeparam>
+    /// <typeparam name="TU">Response</typeparam>
+    public static class AsyncNetworkEngine<TR, TU>
+        where TR : IMessage<TR>, new()
+        where TU : IMessage<TU>, new()
+    {
+        private static readonly MessageParser<TU> _tuParser = new MessageParser<TU>(() => new TU());
+        private static readonly MessageParser<GenericErrorResponse> _tvParser = new MessageParser<GenericErrorResponse>(() => new GenericErrorResponse());
+        private static EventService _eventService = null;
+
+        public static void Send(string uri, TR request, Action<Transmission, TU, GenericErrorResponse> result)
+        {
+            if (_eventService == null) _eventService = ServiceProvider.GetService<EventService>();
+            _eventService.StartCoroutine(SendRequest(uri, request, result));
+        }
+
+        public static IEnumerator SendRequest(string uri, TR request, Action<Transmission, TU, GenericErrorResponse> result)
+        {
+            //Notice: APIGateway automatically converts binary data into base64 strings
+            using var rqt = new UnityWebRequest(uri, "POST")
+            {
+                uploadHandler = new UploadHandlerRaw(request.ToByteArray()),
+                downloadHandler = new DownloadHandlerBuffer()
+            };
+            yield return rqt.SendWebRequest();
+
+            switch (rqt.result)
+            {
+                case UnityWebRequest.Result.ConnectionError:
+                    Return(Transmission.ErrorConnection, result);
+                    break;
+                case UnityWebRequest.Result.ProtocolError:
+                    HandleError(GetCloudProvider(ref uri), rqt, result);
+                    break;
+                case UnityWebRequest.Result.Success:
+                    while (!rqt.downloadHandler.isDone) yield return null;
+                    HandleSuccess(GetCloudProvider(ref uri), rqt, result);
+                    break;
+            }
+        }
+
+        private static CloudProvider GetCloudProvider(ref string url)
+        {
+            if (!AsyncNetworkEngineMap.IsSingleCloud)
+            {
+                foreach (var pair in AsyncNetworkEngineMap.MapCloudProvider)
+                {
+                    if (!url.StartsWith(pair.Key)) continue;
+                    return pair.Value;
+                }
+            }
+            return AsyncNetworkEngineMap.SingleCloudProvider;
+        }
+
+        private static void HandleSuccess(CloudProvider provider, UnityWebRequest rqt, Action<Transmission, TU, GenericErrorResponse> result)
+        {
+            if (rqt.downloadHandler.data == null)
+            {
+                Return(Transmission.ErrorNoData, result);
+                return;
+            }
+            if (rqt.downloadHandler.data.Length <= 0)
+            {
+                Return(Transmission.ErrorNoData, result);
+                return;
+            }
+
+            byte[] data = rqt.downloadHandler.data;
+            if (provider == CloudProvider.AWS)
+            {
+                data = Base64StdEncoding.Decode(Encoding.ASCII.GetString(rqt.downloadHandler.data));
+            }
+
+            TU packet;
+            try
+            {
+                packet = _tuParser.ParseFrom(data);
+            }
+            catch
+            {
+                packet = default;
+            }
+            Return(packet != null ? Transmission.Success : Transmission.ErrorParser, packet, default, result);
+        }
+
+        private static void HandleError(CloudProvider provider, UnityWebRequest rqt, Action<Transmission, TU, GenericErrorResponse> result)
+        {
+            if (rqt.downloadHandler.data == null)
+            {
+                Return(Transmission.ErrorProtocol, result);
+                return;
+            }
+            if (rqt.downloadHandler.data.Length <= 0)
+            {
+                Return(Transmission.ErrorProtocol, result);
+                return;
+            }
+
+            byte[] data = rqt.downloadHandler.data;
+            if (provider == CloudProvider.AWS)
+            {
+                data = Base64StdEncoding.Decode(Encoding.ASCII.GetString(rqt.downloadHandler.data));
+            }
+
+            var transmission = (Transmission)rqt.responseCode;
+            GenericErrorResponse packet;
+            try
+            {
+                packet = _tvParser.ParseFrom(data);
+            }
+            catch
+            {
+                packet = default;
+            }
+            Return(packet != null ? transmission : Transmission.ErrorParser, default, packet, result);
+        }
+
+        private static void Return(Transmission result, Action<Transmission, TU, GenericErrorResponse> callback)
+        {
+            Return(result, default, default, callback);
+        }
+
+        private static void Return(Transmission result, TU data, GenericErrorResponse error, Action<Transmission, TU, GenericErrorResponse> callback)
+        {
+            if (callback == null) return;
+            _eventService.QueueAction(() => callback.Invoke(result, data, error));
+            //callback.Invoke(result, data, error);
+        }
+    }
+}

README.md

@@ -0,0 +1,41 @@
+using System;
+
+namespace GameWorkstore.AsyncNetworkEngine
+{
+
+    public static class Base64StdEncoding
+    {
+        public static string Encode(byte[] input)
+        {
+            var output = Convert.ToBase64String(input);
+            //output = output.Replace('+', '-'); // 62nd char of encoding
+            //output = output.Replace('/', '_'); // 63rd char of encoding
+            output = output.Split('=')[0]; // Remove any trailing '='s
+
+            return output;
+        }
+
+        public static byte[] Decode(string input)
+        {
+            //var output = input;
+            //output = output.Replace('-', '+'); // 62nd char of encoding
+            //output = output.Replace('_', '/'); // 63rd char of encoding
+
+            switch (input.Length % 4) // Pad with trailing '='s
+            {
+                case 0:
+                    break; // No pad chars in this case
+                case 2:
+                    input += "==";
+                    break; // Two pad chars
+                case 3:
+                    input += "=";
+                    break; // One pad char
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(input), "Illegal base64url string!");
+            }
+
+            return Convert.FromBase64String(input);
+        }
+    }
+}