Пример #1
0
        public void CheckSum_StringHashReturnIsNotNull()
        {
            using var fs = new FileStream("test/script.pl", FileMode.Open);
            var hash = CheckSumGenerator.HashOf(fs);

            Assert.IsNotNull(hash, "Hash is not supposed to be null");
        }
Пример #2
0
        public void CheckSum_HashIsAString()
        {
            using var fs = new FileStream("test/script.pl", FileMode.Open);

            var hash = CheckSumGenerator.HashOf(fs);

            Assert.IsInstanceOfType(hash, typeof(string), "Hash is supposed to be a string");
        }
Пример #3
0
        public void CheckSume_HashStringIsNotEqual()
        {
            var data1 = "dataTest";
            var data2 = "data";

            var hash1 = CheckSumGenerator.HashOfASimpleString(data1);
            var hash2 = CheckSumGenerator.HashOfASimpleString(data2);

            Assert.AreNotEqual(hash1, hash2, "Hashes aren't supposed to be equals");
        }
Пример #4
0
        public void CheckSum_HashIsNotEqual()
        {
            using var fs1 = new FileStream("test/script.pl", FileMode.Open);
            using var fs2 = new FileStream("test2/script.py", FileMode.Open);

            var hashFs1 = CheckSumGenerator.HashOf(fs1);
            var hashFs2 = CheckSumGenerator.HashOf(fs2);

            var equals = hashFs1.Equals(hashFs2);

            Assert.IsFalse(equals, "Hashes aren't supposed to be equals");
        }
Пример #5
0
        public HalClient(string ip, int port, int updateIntervalInMs = 100) : base(ip, port, updateIntervalInMs)
        {
            heartbeatStopwatch.Start();

            funcManager.AddFunc(MagicStringEnumerator.CMDAdd, FuncAdd);
            funcManager.AddFunc(MagicStringEnumerator.CMDDel, FuncDel);
            funcManager.AddFunc(MagicStringEnumerator.CMDUpd, FuncUpd);
            funcManager.AddFunc(MagicStringEnumerator.CMDHtb, FuncHtb);

            OnConnected += async(o, e) =>
            {
                if (!Directory.Exists(MagicStringEnumerator.DefaultPluginPath))
                {
                    Directory.CreateDirectory(MagicStringEnumerator.DefaultPluginPath);
                }
                var files = Directory.EnumerateFiles(MagicStringEnumerator.DefaultPluginPath);

                string configFileChecksum;

                try
                {
                    configFileChecksum = await CheckSumGenerator.HashOf(MagicStringEnumerator.DefaultConfigPath);
                }
                catch
                {
                    configFileChecksum = "0";
                }

                await StreamWriter.WriteLineAsync($"{MagicStringEnumerator.DefaultConfigPath};{configFileChecksum}");

                await StreamWriter.FlushAsync();

                foreach (var file in files)
                {
                    var checksum = await CheckSumGenerator.HashOf(file);

                    await StreamWriter.WriteLineAsync($"{file};{checksum}");

                    await StreamWriter.FlushAsync();
                }

                await StreamWriter.WriteLineAsync(MagicStringEnumerator.CMDEnd);

                await StreamWriter.FlushAsync();
            };
        }
Пример #6
0
        public override async Task UpdateAsync()
        {
            var filesUpdated = false;

            var files = Directory.EnumerateFiles(MagicStringEnumerator.DefaultPluginPath);

            foreach (var entry in serverSidedFiles.Values)
            {
                entry.Marked = false;
            }

            foreach (var file in files)
            {
                var checksum = await CheckSumGenerator.HashOf(file);

                var code = await File.ReadAllTextAsync(file);

                var fileName = ConvertUriAbsoluteToLocal(file);

                if (!serverSidedFiles.ContainsKey(fileName))
                {
                    serverSidedFiles.Add(fileName, new MarkedChecksum("0"));
                }

                if (serverSidedFiles[fileName]?.Checksum.Equals(checksum) == false)
                {
                    filesUpdated = true;

                    string path;

                    if (file.Equals(MagicStringEnumerator.DefaultConfigPathServerToClient))
                    {
                        path = MagicStringEnumerator.DefaultRelativeConfigPath + fileName;
                    }
                    else
                    {
                        path = MagicStringEnumerator.DefaultRelativePluginPath + fileName;
                    }

                    serverSidedFiles[fileName].Checksum = checksum;

                    await SendAddCommand(code.Length, path, code);
                }

                serverSidedFiles[fileName].Marked = true;
            }

            if (filesUpdated || firstUpdate)
            {
                firstUpdate = false;
                await SendUpdateCommand();
            }

            /*
             *          foreach(var key in pluginFile.Keys)
             *          {
             *              if(!pluginFile[key].Marked)
             *              {
             *                  await StreamWriter.WriteLineAsync($"DEL\n{key}");
             *                  await StreamWriter.FlushAsync();
             *
             *                  pluginFile.Remove(key);
             *              }
             *          }
             */
        }