+Version 0.2.4

+Rewrote using() to enable backwards compatibility

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,81 @@
+# Async Network Engine
+
+Application Http requests made easy to interoperability with Go Lang Backend + Google Protobuf functions!
+
+Supported Cloud Functions:
+- Google Cloud Functions
+- Amazon Web Services Lambdas
+
+Use at your own risk!
+
+# CppSDK
+
+Visit this repo for more info: https://github.com/GameWorkstore/async-network-engine-cpp
+
+# GoLangSDK
+
+Visit this repo for more info: https://github.com/GameWorkstore/async-network-engine-go
+
+# UnitySDK
+
+## How to install
+
+At package.json, add these 3 lines of code:
+```json
+"com.gameworkstore.asyncnetworkengine": "git://github.com/GameWorkstore/async-network-engine.git#0.2.1",
+"com.gameworkstore.googleprotobufunity": "git://github.com/GameWorkstore/google-protobuf-unity.git#3.15.2006",
+"com.gameworkstore.patterns": "git://github.com/GameWorkstore/patterns.git#1.1.2"
+```
+
+And wait for unity to download and compile the package.
+
+or update package for a newer version, update end of line from 0.2.1 to any released version on Releases.
+
+## Usage Examples
+
+You can find usage examples on Assets/Tests/ folder, for each cloud.
+
+# FAQ
+
+## 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.
+
+## 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,258 @@
+using Google.Protobuf;
+using GameWorkstore.Patterns;
+using System;
+using System.Collections;
+using System.Text;
+using UnityEngine.Networking;
+using System.Collections.Generic;
+using System.Linq;
+// ReSharper disable StaticMemberInGenericType
+
+namespace GameWorkstore.AsyncNetworkEngine
+{
+    public enum CloudProvider
+    {
+        Gcp = 0,
+        Aws = 1
+    }
+
+    public class FileData
+    {
+        public string URL;
+        public byte[] Data;
+    }
+
+    public static class AsyncNetworkEngineMap
+    {
+        internal static bool IsSingleCloud = true;
+        internal static CloudProvider SingleCloudProvider = CloudProvider.Aws;
+        internal static Dictionary<string, CloudProvider> MapCloudProvider;
+
+        /// <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;
+
+        public static void Download(string url,Action<Transmission,FileData> callback)
+        {
+            if (_eventService == null) _eventService = ServiceProvider.GetService<EventService>();
+            _eventService.StartCoroutine(SendRequest(new[] { url }, (result,files) => {
+                callback?.Invoke(result,files.FirstOrDefault());
+            }));
+        }
+
+        public static void Download(string[] urls, Action<Transmission,HighSpeedArray<FileData>> callback)
+        {
+            if (_eventService == null) _eventService = ServiceProvider.GetService<EventService>();
+            _eventService.StartCoroutine(SendRequest(urls, callback));
+        }
+
+        public static IEnumerator SendRequest(string[] urls, Action<Transmission, HighSpeedArray<FileData>> callback)
+        {
+            var data = new HighSpeedArray<FileData>(urls.Length);
+            foreach(var url in urls)
+            {
+                using (var rqt = UnityWebRequest.Get(url))
+				{
+                    yield return rqt.SendWebRequest();
+
+                    switch (rqt.result)
+                    {
+                        case UnityWebRequest.Result.ConnectionError:
+                            Return(Transmission.ErrorConnection, data, callback);
+                            break;
+                        case UnityWebRequest.Result.ProtocolError:
+                            Return(Transmission.ErrorProtocol, data, callback);
+                            break;
+                        case UnityWebRequest.Result.DataProcessingError:
+                            Return(Transmission.ErrorDecode, data, callback);
+                            break;
+                        case UnityWebRequest.Result.Success:
+                            data.Add(new FileData()
+                            {
+                                URL = url,
+                                Data = rqt.downloadHandler.data
+                            });
+                            break;
+                    }
+                }
+            }
+            Return(Transmission.Success, data, callback);
+        }
+
+        private static void Return(Transmission result, HighSpeedArray<FileData> data, Action<Transmission, HighSpeedArray<FileData>> callback)
+        {
+            if (_eventService != null)
+            {
+                _eventService.QueueAction(() => callback.Invoke(result, data));
+            }
+            else
+            {
+                callback?.Invoke(result, data);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Implements a UnityRequest for google protobuf web functions.
+    /// </summary>
+    /// <typeparam name="TRqt">Request</typeparam>
+    /// <typeparam name="TResp">Response</typeparam>
+    public static class AsyncNetworkEngine<TRqt,TResp>
+        where TRqt : IMessage<TRqt>, new()
+        where TResp : IMessage<TResp>, new()
+    {
+        private static readonly MessageParser<TResp> _tuParser = new MessageParser<TResp>(() => new TResp());
+        private static readonly MessageParser<GenericErrorResponse> _tvParser = new MessageParser<GenericErrorResponse>(() => new GenericErrorResponse());
+        private static EventService _eventService;
+
+        public static void Send(string url, TRqt request, Action<Transmission, TResp, GenericErrorResponse> callback)
+        {
+            if (_eventService == null) _eventService = ServiceProvider.GetService<EventService>();
+            _eventService.StartCoroutine(SendRequest(url, request, callback));
+        }
+
+        public static IEnumerator SendRequest(string url, TRqt request, Action<Transmission, TResp, GenericErrorResponse> callback)
+        {
+            //Notice: APIGateway automatically converts binary data into base64 strings
+            using (var rqt = new UnityWebRequest(url, "POST")
+            {
+                uploadHandler = new UploadHandlerRaw(request.ToByteArray()),
+                downloadHandler = new DownloadHandlerBuffer()
+            })
+            {
+                yield return rqt.SendWebRequest();
+
+                switch (rqt.result)
+                {
+                    case UnityWebRequest.Result.ConnectionError:
+                        Return(Transmission.ErrorConnection, callback);
+                        break;
+                    case UnityWebRequest.Result.ProtocolError:
+                        HandleError(GetCloudProvider(ref url), rqt, callback);
+                        break;
+                    case UnityWebRequest.Result.Success:
+                        while (!rqt.downloadHandler.isDone) yield return null;
+                        HandleSuccess(GetCloudProvider(ref url), rqt, callback);
+                        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, TResp, GenericErrorResponse> callback)
+        {
+            if (rqt.downloadHandler.data == null)
+            {
+                Return(Transmission.ErrorNoData, callback);
+                return;
+            }
+
+            var data = rqt.downloadHandler.data;
+            if (provider == CloudProvider.Aws)
+            {
+                var s = Encoding.ASCII.GetString(rqt.downloadHandler.data);
+                if (!Base64StdEncoding.Decode(s, out data))
+                {
+                    Return(Transmission.ErrorParser, default, new GenericErrorResponse(){ Error = "base64 string is invalid:" + s }, callback);
+                    return;
+                }
+            }
+
+            TResp packet;
+            try
+            {
+                packet = _tuParser.ParseFrom(data);
+            }
+            catch
+            {
+                Return(Transmission.ErrorParser, callback);
+                return;
+            }
+            Return(Transmission.Success, packet, default, callback);
+        }
+
+        private static void HandleError(CloudProvider provider, UnityWebRequest rqt, Action<Transmission, TResp, GenericErrorResponse> callback)
+        {
+            if (rqt.downloadHandler.data == null)
+            {
+                Return(Transmission.ErrorProtocol, callback);
+                return;
+            }
+
+            var data = rqt.downloadHandler.data;
+            if (provider == CloudProvider.Aws)
+            {
+                var s = Encoding.ASCII.GetString(rqt.downloadHandler.data);
+                if (!Base64StdEncoding.Decode(s, out data))
+                {
+                    Return(Transmission.ErrorParser, default, new GenericErrorResponse(){ Error = "base64 string is invalid:" + s }, callback);
+                    return;
+                }
+            }
+
+            var transmission = (Transmission)rqt.responseCode;
+            GenericErrorResponse packet;
+            try
+            {
+                packet = _tvParser.ParseFrom(data);
+            }
+            catch
+            {
+                Return(Transmission.ErrorParser, callback);
+                return;
+            }
+            Return(transmission, default, packet, callback);
+        }
+
+        private static void Return(Transmission result, Action<Transmission, TResp, GenericErrorResponse> callback)
+        {
+            Return(result, default, default, callback);
+        }
+
+        private static void Return(Transmission result, TResp data, GenericErrorResponse error, Action<Transmission, TResp, GenericErrorResponse> callback)
+        {
+            if (callback == null) return;
+            if(_eventService != null)
+            {
+                _eventService.QueueAction(() => callback.Invoke(result, data, error));
+            }
+            else
+            {
+                callback.Invoke(result, data, error);
+            }
+        }
+    }
+}