void UnregisterInstance(bool safe)
        {
            if (!registered)
            {
                return;
            }
            GuidData[] registeredApplicationInstances = GetApplicationInstances(true);
            GuidData[] newApplicationInstances        = new GuidData[registeredApplicationInstances.Length - 1];
            int        i = 0;

            foreach (GuidData instance in registeredApplicationInstances)
            {
                if (instance.AsGuid == applicationInstanceId.AsGuid)
                {
                    continue;
                }
                newApplicationInstances[i] = instance;
                ++i;
            }
            UpdateInstancesFile(newApplicationInstances);
            registered = false;
            if (!safe && applicationInstanceHost != null)
            {
                DeleteInstance();
            }
        }
        public async void Can_Get_From_DB_Then_Set_To_Cache_Before_Cached()
        {
            var guid       = Guid.NewGuid();
            var guidString = guid.ToString("N").ToUpper();
            var expected   = new GuidData()
            {
                Guid = guid, User = "******", Expire = DateTimeOffset.UtcNow.AddDays(30).ToUnixTimeSeconds()
            };

            _cacheMock.GetAsync(Arg.Is <string>(x => x == "GuidData_" + guidString)).Returns(default(byte[]));
            _dbMock.GetGuidData(Arg.Is <Guid>(x => x == guid)).Returns(expected);

            var actual = await _repo.GetGuidData(guid);

            Assert.NotNull(actual);
            Assert.Equal(expected.Guid, actual.Guid);
            Assert.Equal(expected.User, actual.User);
            Assert.Equal(expected.Expire, actual.Expire);

            await _cacheMock.Received(1).GetAsync(Arg.Any <string>());

            await _cacheMock.Received(1).SetAsync(Arg.Any <string>(), Arg.Any <byte[]>(), Arg.Any <DistributedCacheEntryOptions>());

            await _dbMock.Received(1).GetGuidData(Arg.Any <Guid>());
        }
        protected bool IsAlive(GuidData instance)
        {
            bool isAliveFlagFileExists  = false;
            Tuple <IntPtr, IntPtr> file = CreateFileMappingAndMapView(1, GetIsAliveFlagFileName(instance), out isAliveFlagFileExists);

            UnmapViewAndCloseFileMapping(file);
            return(isAliveFlagFileExists);
        }
 void DeleteInstance()
 {
     UnmapViewAndCloseFileMapping(isAliveFlagFile);
     isAliveFlagFile = null;
     applicationInstanceHost.Close(new TimeSpan(0, 0, 0, 0, MillisecondsTimeout));
     applicationInstanceHost = null;
     applicationInstanceId   = new GuidData(Guid.Empty);
 }
        // like AMQP does it
        static void WriteUuidSpan(byte[] buffer, Guid data)
        {
            var destination = buffer.AsSpan();

            GuidData guidData = System.Runtime.CompilerServices.Unsafe.As <Guid, GuidData>(ref data);

            destination[15] = guidData._k; // hoist bounds checks
            BinaryPrimitives.WriteInt32BigEndian(destination, guidData._a);
            BinaryPrimitives.WriteInt16BigEndian(destination[4..], guidData._b);
        /// <summary>
        /// Set cache after data created or updated
        /// </summary>
        /// <param name="guidData">The guidData</param>
        /// <returns>The affected data and: <c>true</c> if updating was performed vs creating; otherwise, <c>false</c></returns>
        public async Task <(GuidData, bool)> UpsertGuidData(GuidData guidData)
        {
            var(upserted, isUpdated) = await _decorated.UpsertGuidData(guidData);

            if (upserted != null)
            {
                await _cache.SetStringAsync(_cacheKey(upserted.Guid), JsonConvert.SerializeObject(upserted), _expire(upserted.Expire));
            }
            return(upserted, isUpdated);
        }
        /// <summary>
        /// Set cache after data created
        /// </summary>
        /// <param name="guidData"  cref="GuidData">The guidData</param>
        /// <returns>The newly created GuidData</returns>
        public async Task <GuidData> CreateGuidData(GuidData guidData)
        {
            var created = await _decorated.CreateGuidData(guidData);

            if (created != null)
            {
                await _cache.SetStringAsync(_cacheKey(created.Guid), JsonConvert.SerializeObject(created), _expire(created.Expire));
            }
            return(created);
        }
        void CreateInstance()
        {
            applicationInstanceId   = new GuidData(Guid.NewGuid());
            applicationInstanceHost = new ServiceHost(new ApplicationInstance(this), new Uri(GetServiceUri(applicationInstanceId)));
            applicationInstanceHost.AddServiceEndpoint(typeof(IApplicationInstance), new NetNamedPipeBinding(), EndPointName);
            applicationInstanceHost.Open(new TimeSpan(0, 0, 0, 0, MillisecondsTimeout));
            bool alreadyExists;

            isAliveFlagFile = CreateFileMappingAndMapView(1, GetIsAliveFlagFileName(applicationInstanceId), out alreadyExists);
        }
示例#9
0
 public override int GetHashCode()
 {
     unchecked
     {
         var hashCode = GuidData.GetHashCode();
         hashCode = (hashCode * 397) ^ IntData;
         hashCode = (hashCode * 397) ^ (StringData != null ? StringData.GetHashCode() : 0);
         hashCode = (hashCode * 397) ^ DateData.GetHashCode();
         return(hashCode);
     }
 }
        protected GuidData[] GetApplicationInstances(bool isCurrentProcessApplicationInstance)
        {
            Tuple <IntPtr, IntPtr> instancesFile = GetInstancesFile();
            GuidData listProperties = (GuidData)Marshal.PtrToStructure(instancesFile.Item2, typeof(GuidData));
            int      instancesCount = listProperties.Byte0;

            GuidData[] instances = new GuidData[instancesCount];
            for (int i = 0; i < instancesCount; ++i)
            {
                instances[i] = (GuidData)Marshal.PtrToStructure(instancesFile.Item2 + (1 + i) * Marshal.SizeOf(typeof(GuidData)), typeof(GuidData));
            }
            return(instances);
        }
 void RegisterInstance()
 {
     if (registered)
     {
         return;
     }
     GuidData[] registeredApplicationInstances = GetApplicationInstances(true);
     CreateInstance();
     GuidData[] newApplicationInstances = new GuidData[registeredApplicationInstances.Length + 1];
     newApplicationInstances[0] = applicationInstanceId;
     Array.Copy(registeredApplicationInstances, 0, newApplicationInstances, 1, registeredApplicationInstances.Length);
     UpdateInstancesFile(newApplicationInstances);
     registered = true;
 }
示例#12
0
 public bool Equals(TestPublication other)
 {
     if (ReferenceEquals(null, other))
     {
         return(false);
     }
     if (ReferenceEquals(this, other))
     {
         return(true);
     }
     return(GuidData.Equals(other.GuidData) &&
            IntData == other.IntData &&
            string.Equals(StringData, other.StringData) &&
            DateData.Equals(other.DateData));
 }
        protected void UpdateInstancesFile(GuidData[] instances)
        {
            Tuple <IntPtr, IntPtr> instancesFile = GetInstancesFile();
            byte instancesCount = CorceInstancesCount(instances.Length);

            for (int i = 0; i < instancesCount; ++i)
            {
                Marshal.StructureToPtr(instances[i], instancesFile.Item2 + (1 + i) * Marshal.SizeOf(typeof(GuidData)), false);
            }
            GuidData listProperties = new GuidData()
            {
                Byte0 = instancesCount
            };

            Marshal.StructureToPtr(listProperties, instancesFile.Item2, false);
        }
        public async void Can_Get_From_Cache_After_Cached()
        {
            var guid       = Guid.NewGuid();
            var guidString = guid.ToString("N").ToUpper();
            var raw        = new GuidData {
                Guid = guid, User = "******", Expire = DateTimeOffset.UtcNow.AddDays(30).ToUnixTimeSeconds()
            };
            var cached = JsonConvert.SerializeObject(raw);

            _cacheMock.GetAsync(Arg.Is <string>(x => x == "GuidData_" + guidString)).Returns(Encoding.ASCII.GetBytes(cached));

            var actual = await _repo.GetGuidData(guid);

            Assert.NotNull(actual);
            Assert.Equal(guid, actual.Guid);

            await _dbMock.DidNotReceive().GetGuidData(Arg.Any <Guid>());
        }
示例#15
0
    public IEnumerator GetId(Action <GuidData> onSuccess, Action onFailure)
    {
        using (UnityWebRequest request = UnityWebRequest.Get("https://us-central1-pok-game.cloudfunctions.net/getUniqueGuidRequest"))
        {
            yield return(request.SendWebRequest());

            if (request.isNetworkError == true)
            {
                Debug.LogError("An error has occured while getting user GUID: " + request.error);
                onFailure?.Invoke();
            }
            else
            {
                Debug.Log($"Successfully retrieved GUID: {request.downloadHandler.text}");
                GuidData data = new GuidData();
                data.guid = request.downloadHandler.text;
                onSuccess?.Invoke(data);
            }
        }
    }
        public async void Can_Set_To_Cache_When_Upserted()
        {
            var guid       = Guid.NewGuid();
            var guidString = guid.ToString("N").ToUpper();
            var expected   = new GuidData()
            {
                Guid = guid, User = "******", Expire = DateTimeOffset.UtcNow.AddDays(30).ToUnixTimeSeconds()
            };

            _dbMock.UpsertGuidData(Arg.Is <GuidData>(x => x.Guid == expected.Guid)).Returns((expected, true));

            var(actual, isUpdated) = await _repo.UpsertGuidData(expected);

            Assert.NotNull(actual);
            Assert.Equal(expected.Guid, actual.Guid);
            Assert.Equal(expected.User, actual.User);
            Assert.Equal(expected.Expire, actual.Expire);

            await _dbMock.Received(1).UpsertGuidData(Arg.Any <GuidData>());

            await _cacheMock.Received(1).SetAsync(Arg.Any <string>(), Arg.Any <byte[]>(), Arg.Any <DistributedCacheEntryOptions>());
        }
        /// <summary>
        /// Create GuidData
        /// </summary>
        /// <param name="guidData" cref="GuidData">The guidData</param>
        /// <returns>The created guidData</returns>
        /// <exception cref="ConflictResourceException">If the guid already exists</exception>
        async Task <GuidData> IGuidDataRepository.CreateGuidData(GuidData guidData)
        {
            try
            {
                using (var db = new SqlConnection(_connectionString))
                {
                    db.Open();

                    await db.ExecuteAsync(
                        "dbo.CreateGuidData",
                        new { guid = guidData.Guid, user = guidData.User, expire = guidData.Expire },
                        commandTimeout : _commandTimeoutInSeconds,
                        commandType : CommandType.StoredProcedure);

                    return(guidData);
                }
            }
            catch (SqlException ex) when(ex.Number == 2601 || ex.Number == 2627)
            {
                throw new ConflictResourceException(ex);
            }
        }
 void UnregisterInstance(bool safe) {
     if(!registered) return;
     GuidData[] registeredApplicationInstances = GetApplicationInstances(true);
     GuidData[] newApplicationInstances = new GuidData[registeredApplicationInstances.Length - 1];
     int i = 0;
     foreach(GuidData instance in registeredApplicationInstances) {
         if(instance.AsGuid == applicationInstanceId.AsGuid) continue;
         newApplicationInstances[i] = instance;
         ++i;
     }
     UpdateInstancesFile(newApplicationInstances);
     registered = false;
     if(!safe && applicationInstanceHost != null)
         DeleteInstance();
 }
 void CreateInstance() {
     applicationInstanceId = new GuidData(Guid.NewGuid());
     applicationInstanceHost = new ServiceHost(new ApplicationInstance(this), new Uri(GetServiceUri(applicationInstanceId)));
     applicationInstanceHost.AddServiceEndpoint(typeof(IApplicationInstance), new NetNamedPipeBinding(), EndPointName);
     applicationInstanceHost.Open(new TimeSpan(0, 0, 0, 0, MillisecondsTimeout));
     bool alreadyExists;
     isAliveFlagFile = CreateFileMappingAndMapView(1, GetIsAliveFlagFileName(applicationInstanceId), out alreadyExists);
 }
 void DeleteInstance() {
     UnmapViewAndCloseFileMapping(isAliveFlagFile);
     isAliveFlagFile = null;
     applicationInstanceHost.Close(new TimeSpan(0, 0, 0, 0, MillisecondsTimeout));
     applicationInstanceHost = null;
     applicationInstanceId = new GuidData(Guid.Empty);
 }
 protected void UpdateInstancesFile(GuidData[] instances) {
     Tuple<IntPtr, IntPtr> instancesFile = GetInstancesFile();
     byte instancesCount = CorceInstancesCount(instances.Length);
     for(int i = 0; i < instancesCount; ++i)
         Marshal.StructureToPtr(instances[i], instancesFile.Item2 + (1 + i) * Marshal.SizeOf(typeof(GuidData)), false);
     GuidData listProperties = new GuidData() { Byte0 = instancesCount };
     Marshal.StructureToPtr(listProperties, instancesFile.Item2, false);
 }
 void RegisterInstance() {
     if(registered) return;
     GuidData[] registeredApplicationInstances = GetApplicationInstances(true);
     CreateInstance();
     GuidData[] newApplicationInstances = new GuidData[registeredApplicationInstances.Length + 1];
     newApplicationInstances[0] = applicationInstanceId;
     Array.Copy(registeredApplicationInstances, 0, newApplicationInstances, 1, registeredApplicationInstances.Length);
     UpdateInstancesFile(newApplicationInstances);
     registered = true;
 }
 protected Tuple<MemoryMappedFile, int> GetInstancesFile() {
     InstancesProperties listProperties;
     using(var acccessor = InstancesPropertiesFile.CreateViewAccessor())
         acccessor.Read(0, out listProperties);
     if(listProperties.NameSuffix.AsGuid != instancesFileNameSuffix.AsGuid) {
         if(instancesFile != null)
             instancesFile.Dispose();
         instancesFileNameSuffix = listProperties.NameSuffix;
         instancesFile = instancesFileNameSuffix.AsGuid == Guid.Empty ? null : MemoryMappedFile.OpenExisting(GetInstancesFileName(instancesFileNameSuffix));
     }
     return new Tuple<MemoryMappedFile, int>(instancesFile, listProperties.InstancesCount);
 }
 protected bool IsAlive(GuidData instance) {
     bool isAliveFlagFileExists = false;
     Tuple<IntPtr, IntPtr> file = CreateFileMappingAndMapView(1, GetIsAliveFlagFileName(instance), out isAliveFlagFileExists);
     UnmapViewAndCloseFileMapping(file);
     return isAliveFlagFileExists;
 }
 void SendExecuteMessage(GuidData[] applicationInstances, string command) {
     List<Exception> exceptions = null;
     foreach(GuidData applicationInstanceId in applicationInstances) {
         try {
             using(ChannelFactory<IApplicationInstance> pipeFactory = new ChannelFactory<IApplicationInstance>(new NetNamedPipeBinding(), new EndpointAddress(string.Format("{0}/{1}", GetServiceUri(applicationInstanceId), EndPointName)))) {
                 IApplicationInstance pipeProxy = pipeFactory.CreateChannel();
                 pipeProxy.Execute(command);
             }
         } catch(CommunicationException) {
         } catch(Exception e) {
             if(exceptions == null)
                 exceptions = new List<Exception>();
             exceptions.Add(e);
         }
     }
     if(exceptions != null)
         throw new InvalidOperationException("", new AggregateException(exceptions.ToArray()));
 }
 void DeleteInstance() {
     applicationInstanceHost.Close(new TimeSpan(0, 0, 0, 0, MillisecondsTimeout));
     applicationInstanceHost = null;
     applicationInstanceId = new GuidData(Guid.Empty);
 }
 string GetInstancesFileName(GuidData instancesFileNameSuffix) {
     return InstancesFileNamePrefix + instancesFileNameSuffix.AsGuid.ToString();
 }
 protected void UpdateInstancesFile(GuidData[] instances) {
     if(instancesFile != null)
         instancesFile.Dispose();
     if(instances.Length != 0) {
         instancesFileNameSuffix = new GuidData(Guid.NewGuid());
         instancesFile = MemoryMappedFile.CreateNew(GetInstancesFileName(instancesFileNameSuffix), instances.Length * Marshal.SizeOf(typeof(GuidData)));
         using(var accessor = instancesFile.CreateViewAccessor())
             accessor.WriteArray(0, instances, 0, instances.Length);
     } else {
         instancesFile = null;
         instancesFileNameSuffix = new GuidData(Guid.Empty);
     }
     InstancesProperties listProperties = new InstancesProperties() { InstancesCount = instances.Length, NameSuffix = instancesFileNameSuffix };
     using(var acccessor = InstancesPropertiesFile.CreateViewAccessor())
         acccessor.Write(0, ref listProperties);
 }
 void CreateInstance() {
     applicationInstanceId = new GuidData(Guid.NewGuid());
     applicationInstanceHost = new ServiceHost(new ApplicationInstance(this), new Uri(GetServiceUri(applicationInstanceId)));
     applicationInstanceHost.AddServiceEndpoint(typeof(IApplicationInstance), new NetNamedPipeBinding(), EndPointName);
     applicationInstanceHost.Open(new TimeSpan(0, 0, 0, 0, MillisecondsTimeout));
 }
 protected static string GetIsAliveFlagFileName(GuidData applicationInstance)
 {
     return(string.Format("IsAlive_{0}{1}", InstanceNamePrefix, applicationInstance.AsGuid));
 }
 protected static string GetServiceUri(GuidData applicationInstance)
 {
     return(string.Format("net.pipe://localhost/{0}{1}", InstanceNamePrefix, applicationInstance.AsGuid));
 }
 protected static string GetServiceUri(GuidData applicationInstance) {
     return string.Format("net.pipe://localhost/{0}{1}", InstanceNamePrefix, applicationInstance.AsGuid);
 }
 protected static string GetIsAliveFlagFileName(GuidData applicationInstance) {
     return string.Format("IsAlive_{0}{1}", InstanceNamePrefix, applicationInstance.AsGuid);
 }
 void UnregisterInstance() {
     if(applicationInstanceHost == null) return;
     GuidData[] registeredApplicationInstances = GetApplicationInstances();
     GuidData[] newApplicationInstances = new GuidData[registeredApplicationInstances.Length - 1];
     int i = 0;
     foreach(GuidData instance in registeredApplicationInstances) {
         if(instance.AsGuid == applicationInstanceId.AsGuid) continue;
         newApplicationInstances[i] = instance;
         ++i;
     }
     UpdateInstancesFile(newApplicationInstances);
     DeleteInstance();
 }
 protected GuidData[] GetApplicationInstances(bool isCurrentProcessApplicationInstance) {
     Tuple<IntPtr, IntPtr> instancesFile = GetInstancesFile();
     GuidData listProperties = (GuidData)Marshal.PtrToStructure(instancesFile.Item2, typeof(GuidData));
     int instancesCount = listProperties.Byte0;
     GuidData[] instances = new GuidData[instancesCount];
     for(int i = 0; i < instancesCount; ++i)
         instances[i] = (GuidData)Marshal.PtrToStructure(instancesFile.Item2 + (1 + i) * Marshal.SizeOf(typeof(GuidData)), typeof(GuidData));
     return instances;
 }
 void RegisterInstance(GuidData[] registeredApplicationInstances = null) {
     if(applicationInstanceHost != null) return;
     if(registeredApplicationInstances == null)
         registeredApplicationInstances = GetApplicationInstances();
     CreateInstance();
     GuidData[] newApplicationInstances = new GuidData[registeredApplicationInstances.Length + 1];
     newApplicationInstances[0] = applicationInstanceId;
     Array.Copy(registeredApplicationInstances, 0, newApplicationInstances, 1, registeredApplicationInstances.Length);
     UpdateInstancesFile(newApplicationInstances);
 }
 protected GuidData[] GetApplicationInstances() {
     Tuple<MemoryMappedFile, int> instancesFile = GetInstancesFile();
     if(instancesFile.Item2 == 0) return new GuidData[] { };
     GuidData[] instances = new GuidData[instancesFile.Item2];
     using(var accessor = instancesFile.Item1.CreateViewAccessor())
         accessor.ReadArray(0, instances, 0, instances.Length);
     return instances;
 }