예제 #1
0
        public void ClearDatabase(string filePath)
        {
            var appendToFile = false;
            var value        = "";

            _fileWriter.Write(filePath, appendToFile, value);
        }
예제 #2
0
 public void Write(byte[] buffer, int bufferOffset, int bufferSize)
 {
     semaphore.Wait();
     try
     {
         decoratee.Write(buffer, bufferOffset, bufferSize);
     }
     finally
     {
         semaphore.Release();
     }
 }
예제 #3
0
        public void Log(ErrorDetails errorDetails)
        {
            if (_errorFilter.SkipError(errorDetails.Exception))
            {
                return;
            }

            var formattedException = _exceptionSerializer.Serialize(errorDetails.Exception);
            var rawRequest         = errorDetails.HttpRequest.AsRawString();

            var content = new StringBuilder();

            content.AppendLine(DateTime.UtcNow.ToString("dddd, dd MMMM yyyy HH:mm:ss"));
            content.AppendLine("");
            content.AppendLine("Exception:");
            content.AppendLine("--------------");
            content.AppendLine(formattedException);
            content.AppendLine("");
            content.AppendLine("HTTP Request:");
            content.AppendLine("--------------");
            content.AppendLine(rawRequest);

            var logFilePath = _logFilePathGenerator.CreateNewLogFilePath();

            _fileWriter.Write(logFilePath, content.ToString());
        }
예제 #4
0
        public void Execute()
        {
            while (generator.TryDequeue(out var info))
            {
                if (info.source.size > readBuffer.Length)
                {
                    readBuffer = new byte[info.source.size];
                }
                if (info.target.size > decompressBuffer.Length)
                {
                    decompressBuffer = new byte[info.target.size];
                }

                reader.Read(readBuffer, 0, info.source.size, info.source.offset);

                var decompressedSize = decompressor.Decompress(readBuffer, 0, info.source.size, decompressBuffer);

                if (decompressedSize != info.target.size)
                {
                    throw new Exception();
                }

                writer.Write(decompressBuffer, 0, info.target.size, info.target.offset);
            }
        }
예제 #5
0
        private static void ExtractFiles(FileList fileList, IFileWriter writer)
        {
            Console.WriteLine($"Extracting {fileList.Name}");

            writer.CreateDirectory(fileList.Name);

            foreach (FileData file in fileList.GetFiles())
            {
                if (file.Compressed)
                {
                    using (var compressed = new MemoryStream(file.Contents))
                    {
                        using (var decompressed = new MemoryStream())
                        {
                            LZSS.Decompress(compressed, decompressed);
                            file.Contents = decompressed.ToArray();
                        }
                    }
                }

                if (file.IsArchive())
                {
                    ExtractFiles(new ArchiveFileList(Path.Combine(fileList.Name, file.Name), file.Contents), writer);
                }
                else
                {
                    writer.Write(Path.Combine(fileList.Name, $"{file.Name}.{file.GetExtension()}"), file.Contents);
                }
            }
        }
예제 #6
0
        private void MainLoop()
        {
            while (!_exit)
            {
                LogLine logLine = null;
                try
                {
                    logLine = _lines.Take();
                }
                catch (Exception)
                {
                    _exit = true;
                }

                if (logLine != null && (!_exit || _quitWithFlush))
                {
                    _writer.Write(logLine);
                }

                if (_quitWithFlush && _lines.Count == 0)
                {
                    _exit = true;
                }
            }

            _lines?.Dispose();
            _writer?.Dispose();
        }
예제 #7
0
        public override void SaveTo(IEnumerable <Chunk> chunks, IFileWriter fileWriter)
        {
            if (fileWriter == null)
            {
                throw new ArgumentNullException(nameof(fileWriter));
            }

            long lengthTotal = 0;

            using (fileWriter)
            {
                foreach (var item in chunks)
                {
                    if (item != null)
                    {
                        var buffer    = item.Buffer;
                        var totalSize = BitConverter.GetBytes(buffer.Length);
                        var size      = BitConverter.GetBytes(item.Length);
                        buffer = ConcatArrays(totalSize, buffer, size);

                        fileWriter.Write(buffer, buffer.Length);
                        lengthTotal += item.Length;
                    }
                }

                WriteTotalLength(fileWriter, lengthTotal);
            }
        }
예제 #8
0
        public void Reverse(string inputFile, string outputFile)
        {
            var content         = _fileReader.Read(inputFile);
            var reversedContent = new string(content.Reverse().ToArray());

            _fileWriter.Write(outputFile, reversedContent);
        }
예제 #9
0
        public void Log(LogLevel level, string logMessage)
        {
            string path    = _filePathProvider.GetFilePath();
            var    logInfo = GetLogInfo(level);
            string message = GetMessage(logInfo.Item1, logMessage, _dateTimeProvider.UtcNow);

            _fileWriter.Write(path, message);
        }
예제 #10
0
        /// <summary>
        /// Generates a report filled with the content supplied by <paramref name="report"/>.
        /// </summary>
        /// <param name="report">Specifies the report model.</param>
        public void Generate(IReport report)
        {
            var contentBuilder = CreateContent(report);

            _fileWriter.Write(
                string.Concat(report.ReflectedAssembly, ".txt"),
                writer => writer.Write(contentBuilder.ToString()));
        }
예제 #11
0
        public void WriteFile_Should_Write_The_ExpectedMessage_To_Expected_Path()
        {
            const string path    = "Path";
            const string message = "Message";

            _fileWriter.Write(path, message);
            _fileWriterWrapperMock.Received().Write(Arg.Is(path), Arg.Is(message));
        }
예제 #12
0
        /// <summary>
        /// Writes a DataTable to a CSV file specified by the path
        /// </summary>
        /// <param name="dataTable">The datatable to write</param>
        /// <param name="filePath">The location of the CSV to create</param>
        /// <param name="settings">Optional csv settings</param>
        public static void ToCsv(this DataTable dataTable, string filePath, ToCsvSettings settings = null)
        {
            settings = settings ?? new ToCsvSettings();

            using (IFileWriter fileWriter = FileWriterFactory.GetFileWriter(filePath, settings.Compression))
            {
                fileWriter.Write(dataTable.ToCsv(settings));
            }
        }
예제 #13
0
        public void GenerateReport(string source, string rootModule, string destination)
        {
            _netlistDataBuilder.Build(source);

            var result = _countLibraryGatesQuery.CountLibraryGates(source, rootModule);

            var content = _countLibraryGatesFileContentDirector.Construct(result);

            _fileWriter.Write(destination, "Count Library Gates", content);
        }
예제 #14
0
        public void Save(object data)
        {
            BinaryFormatter formatter = new BinaryFormatter();

            using (MemoryStream stream = new MemoryStream()){
                formatter.Serialize(stream, data);
                byte[] bytes = stream.ToArray();
                fileWriter.Write(bytes, savePath);
            }
        }
예제 #15
0
        public void Generate(RawFileSchema rawFileSchema, DataSource dataSource)
        {
            var validationErrors = _schemaValidator.ValidateSchema(rawFileSchema);

            if (validationErrors.Any())
            {
                throw new Exception("Errors");
            }

            var fileFormat = rawFileSchema.FileFormat.ToEnum <FileSchemaType>();

            var rootDirectory = Path.Combine(_rootFolder, rawFileSchema.RootOutputDir);

            if (!Directory.Exists(rootDirectory))
            {
                Directory.CreateDirectory(rootDirectory);
            }

            var generatedFilePath = Path.Combine(rootDirectory, rawFileSchema.OutputFileName);

            if (!string.IsNullOrWhiteSpace(rawFileSchema.OutputFileExtension))
            {
                generatedFilePath += rawFileSchema.OutputFileExtension;
            }

            switch (fileFormat)
            {
            case FileSchemaType.Fixed:
                var fixedLengthFileSchemaBuilder = new FixedLengthSchemaBuilder();
                var fixedFileSchema = fixedLengthFileSchemaBuilder.BuildSchema(rawFileSchema);
                _fileWriter.Write(generatedFilePath, dataSource, fixedFileSchema);
                break;

            case FileSchemaType.Separated:
                var separatedFileSchemaBuilder = new SeparatedSchemaBuilder();
                var separatedFileSchema        = separatedFileSchemaBuilder.BuildSchema(rawFileSchema);
                _fileWriter.Write(generatedFilePath, dataSource, separatedFileSchema);
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
예제 #16
0
        public void GenerateReport(string source, string rootModule, IList <string> moduleNames, string destination)
        {
            _netlistDataBuilder.Build(source);

            var result = _physicalPathQuery.GetPhysicalPaths(source, rootModule, moduleNames);

            var content = _listPhysicalPathsFileContentDirector.Construct(moduleNames, result);

            _fileWriter.Write(destination, "List Phyisical Paths", content);
        }
예제 #17
0
 public async Task MakeFiles(string fileKeyPath, string fileSavePath, int findNum, Encoding encoding)
 => await Task.Run(async() =>
 {
     var tmp1 = await _fileReader.Read(fileKeyPath, encoding);
     foreach (var name in tmp1)
     {
         var tmp2 = _googleQuery.PageParser(GetQuery(name, findNum));
         await _fileWriter.Write(fileSavePath, name, findNum, encoding, tmp2);
     }
 });
예제 #18
0
        public void PortsToUpper(UpperCasePortsRequest request)
        {
            _netlistDataBuilder.Build(request.SourceNetlist);
            _netlistCloner.Clone(request.SourceNetlist, request.TargetNetlist);

            _libraryGatesPortsReplacer.PortsToUpper(request.TargetNetlist);

            var content = _netlistFileContentDirector.Construct(request.TargetNetlist);

            _fileWriter.Write(request.TargetNetlist, "Uppercase Library Gates Ports", content);
        }
예제 #19
0
        public IEnumerable <string> PerformSort(IEnumerable <Record> records)
        {
            IEnumerable <string> listOfAddresses = records.Select(p => p.Address);

            //Sort Addresses by Street Name
            IOrderedEnumerable <string> sortedAddresses = listOfAddresses.OrderBy(s => s.Split(' ')[1]);

            _writer.Write(sortedAddresses, address => $"{address}", @"Result_2.txt");

            return(sortedAddresses);
        }
예제 #20
0
        private void serialPort_DataRecieved(object sender, SerialDataReceivedEventArgs serialDataReceivedEventArgs)
        {
            var buffer = serialPort.ReadExisting();

            foreach (char c in buffer)
            {
                fileWriter.Write(c.ToString().Trim());
                BytesCounter++;
            }
            // fileWriter.WriteLine(Convert.ToChar(serialPort.ReadByte()).ToString());
        }
예제 #21
0
        public void Save(User user)
        {
            _synchronizer.Lock(() =>
            {
                var allUsers = GetAll().ToList();
                allUsers.Add(user);

                string serialized = _serializer.Serialize(allUsers);
                _writer.Write(_file, serialized);
            });
        }
예제 #22
0
        public void Remove(RemoveBufferRequest removeBufferRequest)
        {
            _netlistDataBuilder.Build(removeBufferRequest.SourceNetlist);
            _netlistCloner.Clone(removeBufferRequest.SourceNetlist, removeBufferRequest.TargetNetlist);

            _bufferRemover.Remove(removeBufferRequest.TargetNetlist, removeBufferRequest.BufferName, removeBufferRequest.InputPort, removeBufferRequest.OutputPort);

            var content = _netlistFileContentDirector.Construct(removeBufferRequest.TargetNetlist);

            _fileWriter.Write(removeBufferRequest.TargetNetlist, "Remove Buffers", content);
        }
        public void Replace(LibraryGateReplaceRequest replaceRequest)
        {
            _netlistDataBuilder.Build(replaceRequest.SourceNetlist);
            _netlistCloner.Clone(replaceRequest.SourceNetlist, replaceRequest.TargetNetlist);

            _libraryGateReplacer.Replace(replaceRequest.TargetNetlist, replaceRequest.GateToReplace, replaceRequest.NewGate, replaceRequest.PortsMapping);

            var content = _netlistFileContentDirector.Construct(replaceRequest.TargetNetlist);

            _fileWriter.Write(replaceRequest.TargetNetlist, "Replace Library Gate", content);
        }
예제 #24
0
        public void SaveReportFile(ReportBundle reportBundle, [NotNull] ReportFile reportFile, long userId)
        {
            if (reportFile == null)
            {
                throw new ArgumentNullException(nameof(reportFile));
            }

            var reportFolderPath = _reportFolderPathProvider.GetReportFolderPath(reportBundle, userId);

            _fileWriter.Write(reportFolderPath, reportFile.FileName, reportFile.Content);
        }
예제 #25
0
        async void DownloadImage(Uri uri)
        {
            var fileName = uri.Segments.Last();

            if (!downloadedImages.TryAdd(fileName, null))
            {
                return;
            }
            var imgBytes = await httpClient.GetByteArray(uri);

            fileWriter.Write(fileName, imgBytes);
        }
예제 #26
0
        protected internal override void DoLog(LogCatagory catagory, string message)
        {
            if (catagory != LogCatagory.Debug) // TODO: Take this from configuration, rather than hard code.
            {
                _fileWriter.Write(_filePath, message);
            }

            if (_logger != null)
            {
                _logger.DoLog(catagory, message);
            }
        }
        /// <summary>
        /// Lets outgoing requests pass through, to log requests and responses
        /// </summary>
        /// <param name="request"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        protected async override Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            var response = await base.SendAsync(request, cancellationToken);

            // we do all the work AFTER the request is sent, so we have the response and if an exception is throw we don't need to run any logic

            var summary = await Summarize(request, response);

            FileWriter.Write(summary);

            return(response);
        }
예제 #28
0
        public void Generate(IEnumerable <MetricResult> results)
        {
            addHtmlHeader();

            foreach (var result in results)
            {
                convertResultToHtml(result);
            }

            addHtmlTail();

            _fileWriter.Write(_filePath, Contents);
        }
예제 #29
0
        private void WriteToAll(string message, LogLevel logLevel)
        {
            var logRecord = new LogRecord()
            {
                CreatedAt            = DateTime.Now,
                LogLevel             = logLevel,
                Message              = message,
                NotSerializableField = "NotSerializableField" + DateTime.Now.ToString()
            };

            FileRepository.Write(logRecord);
            DbRepository.Write(logRecord);
            ConsoleWriter.Write(logRecord);
        }
예제 #30
0
        public void Generate(IEnumerable <MetricResult> results)
        {
            var root = _doc.Root;

            Debug.Assert(root != null);
            foreach (var metricResult in results)
            {
                var metricElement = ConvertResult(metricResult);
                root.Add(metricElement);
            }
            var contents = ToString();

            _fileWriter.Write(_filePath, contents);
        }