Merge pull request EvilBeaver#1630 from asosnoviy/fix/rawStream

EvilBeaver · web-flow · commit 11d8c5fb638b · 2025-12-13T13:56:12.000+03:00
Fix RAW HTTPStream
diff --git a/src/OneScript.StandardLibrary/Http/HttpResponseBody.cs b/src/OneScript.StandardLibrary/Http/HttpResponseBody.cs
@@ -23,9 +23,10 @@ class HttpResponseBody : IDisposable
         bool _backFileIsTemp = false;
         byte[] _inMemBody;
 
-        private readonly bool _autoDecompress; 
+        private readonly bool _autoDecompress;
         private long _contentSize = 0;
-        private Stream _rawStream;
+        private readonly Stream _rawStream;
+        private bool _inMemoryResponseInited;
 
         public HttpResponseBody(HttpWebResponse response, string dumpToFile)
         {
@@ -35,69 +36,81 @@ public HttpResponseBody(HttpWebResponse response, string dumpToFile)
                 return;
             }
 
+            _inMemoryResponseInited = false;
             _rawStream = response.GetResponseStream();
             _autoDecompress = string.Equals(response.ContentEncoding, "gzip", StringComparison.OrdinalIgnoreCase);
             _contentSize = _autoDecompress ? -1 : response.ContentLength;
 
             if (!String.IsNullOrEmpty(dumpToFile))
             {
-                 InitFileBackedResponse(response, dumpToFile);
+                InitFileBackedResponse(dumpToFile);
             }
             else if(_autoDecompress)
             {
-                InitInMemoryResponse(response);
+                InitInMemoryResponse();
             }
         }
 
-        private void InitInMemoryResponse(HttpWebResponse response)
+        private void InitInMemoryResponse()
         {
             if(_contentSize > INMEMORY_BODY_LIMIT)
             {
                 var filename = Path.GetTempFileName();
                 _backFileIsTemp = true;
-                InitFileBackedResponse(response, filename);
+                InitFileBackedResponse(filename);
             }
             else
             {
                 if(_contentSize == UNDEFINED_LENGTH)
                 {
-                    ReadToStream(response);
+                    ReadToStream();
                 }
                 else
                 {
-                    ReadToArray(response);
+                    ReadToArray();
                 }
             }
+            _inMemoryResponseInited = true;
         }
 
         public bool AutoDecompress => _autoDecompress;
 
         public long ContentSize => _contentSize < 0 ? 0 : _contentSize;
 
-        public Stream OpenReadStream()
+        public Stream OpenReadStream(bool raw = false)
         {
+            if (raw)
+            {
+                return GetResponseStream();
+            }
+
+            if (!_inMemoryResponseInited)
+            {
+                InitInMemoryResponse();
+            }
+
             if (_backingFileName != null)
             {
                 return new FileStream(_backingFileName, FileMode.Open, FileAccess.Read);
             }
-           else if (_inMemBody != null)
-           {
-               return new MemoryStream(_inMemBody);
-           }
+            else if (_inMemBody != null)
+            {
+                return new MemoryStream(_inMemBody);
+            }
             else
-                return _rawStream;
+                throw new InvalidOperationException("No response body");
         }
 
-        private Stream GetResponseStream(HttpWebResponse response)
+        private Stream GetResponseStream()
         {
             if (_autoDecompress)
-                return new GZipStream(response.GetResponseStream(), CompressionMode.Decompress);
-            return response.GetResponseStream();
+                return new GZipStream(_rawStream, CompressionMode.Decompress);
+            return _rawStream;
         }
-        
-        private void ReadToStream(HttpWebResponse response)
+
+        private void ReadToStream()
         {
-            using (var responseStream = GetResponseStream(response))
+            using (var responseStream = GetResponseStream())
             using(var ms = new MemoryStream())
             {
                 bool memStreamIsAlive = true;
@@ -119,7 +132,7 @@ private void ReadToStream(HttpWebResponse response)
                         var filename = Path.GetTempFileName();
                         _backFileIsTemp = true;
                         _backingFileName = filename;
-                        
+
                         ms.Position = 0;
                         using (var file = new FileStream(filename, FileMode.Create))
                         {
@@ -146,11 +159,11 @@ private void ReadToStream(HttpWebResponse response)
             }
         }
 
-        private void ReadToArray(HttpWebResponse response)
+        private void ReadToArray()
         {
             System.Diagnostics.Debug.Assert(_contentSize <= INMEMORY_BODY_LIMIT);
-            
-            using var stream = GetResponseStream(response);
+
+            using var stream = GetResponseStream();
             var mustRead = (int)_contentSize;
             _inMemBody = new byte[mustRead];
             int offset = 0;
@@ -168,10 +181,10 @@ private void ReadToArray(HttpWebResponse response)
             }
         }
 
-        private void InitFileBackedResponse(HttpWebResponse response, string backingFileName)
+        private void InitFileBackedResponse(string backingFileName)
         {
             _backingFileName = backingFileName;
-            using(var responseStream = GetResponseStream(response))
+            using (var responseStream = GetResponseStream())
             {
                 using(var file = new FileStream(backingFileName, FileMode.Create))
                 {
@@ -195,7 +208,7 @@ private static void StreamToStreamCopy(Stream responseStream, Stream acceptor)
 
         private void Dispose(bool manualDispose)
         {
-            if(manualDispose)
+            if (manualDispose)
             {
                 GC.SuppressFinalize(this);
                 _inMemBody = null;
diff --git a/src/OneScript.StandardLibrary/Http/HttpResponseContext.cs b/src/OneScript.StandardLibrary/Http/HttpResponseContext.cs
@@ -154,14 +154,14 @@ public IValue GetBodyAsBinaryData()
         /// <summary>
         /// Интерпретировать ответ, как Поток
         /// </summary>
+        /// <param name="rawStream">Булево. Будет получен сырой поток без дополнительной обработки. По умолчанию Ложь</param>
         /// <returns>Поток</returns>
         [ContextMethod("ПолучитьТелоКакПоток", "GetBodyAsStream")]
-        public IValue GetBodyAsStream()
+        public IValue GetBodyAsStream(bool rawStream = false)
         {
             if (_body == null)
                 return ValueFactory.Create();
-
-            return new GenericStream(_body.OpenReadStream(), true);
+            return new GenericStream(_body.OpenReadStream(rawStream), true);
         }
 
         /// <summary>
diff --git a/tests/global-funcs.os b/tests/global-funcs.os
@@ -6,12 +6,18 @@
 ///////////////////////////////////////////////////////////////////////
 
 Перем юТест;
+Перем мАдресРесурса; // URL ресурса (хоста) для тестирования запросов
 
 ////////////////////////////////////////////////////////////////////
 // Программный интерфейс
 
 Функция ПолучитьСписокТестов(ЮнитТестирование) Экспорт
 	
+	Если мАдресРесурса = Неопределено Тогда
+		ПодключитьСценарий("./tests/http.os", "http_тест");
+		мАдресРесурса = Новый http_тест().ВыбратьДоступныйХост();
+	КонецЕсли;
+
 	юТест = ЮнитТестирование;
 	
 	ВсеТесты = Новый Массив;
@@ -652,7 +658,7 @@
 
 	Приемник = ПолучитьИмяВременногоФайла();
 
-	КопироватьФайл("http://httpbin.org/image", Приемник);
+	КопироватьФайл(мАдресРесурса + "/image", Приемник);
 
 	Попытка
 		ДД = Новый ДвоичныеДанные(Приемник);
@@ -670,7 +676,7 @@
 
 	Приемник = ПолучитьИмяВременногоФайла();
 
-	КопироватьФайл("https://httpbin.org/image", Приемник);
+	КопироватьФайл(мАдресРесурса + "/image", Приемник);
 
 	Попытка
 		ДД = Новый ДвоичныеДанные(Приемник);
@@ -689,7 +695,7 @@
 	Приемник = ПолучитьИмяВременногоФайла();
 
 	Попытка
-		ПереместитьФайл("http://httpbin.org/image", Приемник);
+		ПереместитьФайл(мАдресРесурса + "/image", Приемник);
 	Исключение
 		//Отвалится по 405, значит delete метод отрабатывает
 		Описание = ОписаниеОшибки();
diff --git a/tests/http.os b/tests/http.os
@@ -39,6 +39,10 @@
 	ВсеТесты.Добавить("ТестДолженПроверитьЧтоМетодыБезТелаПриУстановленномТелеУспешноВыполняются");
 	ВсеТесты.Добавить("ТестДолженПроверитьЧтоРаботаетПолучениеДвоичныхДанныхИзОтвета");
 
+	ВсеТесты.Добавить("ТестДолженПроверитьЧтоТелоМожноПолучитьНесколькоРаз");
+	ВсеТесты.Добавить("ТестДолженПроверитьПолучениеТелаПослеЗакрытогоПотока");
+	ВсеТесты.Добавить("ТестДолженПроверитьНедоступностьЧистогоПотокаПослеПолученияТела");
+
 	ВсеТесты.Добавить("ТестДолженПроверитьПолучениеStreamEvent");
 
 	Возврат ВсеТесты;
@@ -390,6 +394,72 @@
 	юТест.ПроверитьТип(ДД, Тип("ДвоичныеДанные"));
 	юТест.ПроверитьРавенство(ДД.Размер(), 10);
 
+КонецПроцедуры
+
+ Процедура ТестДолженПроверитьЧтоТелоМожноПолучитьНесколькоРаз() Экспорт
+
+	Запрос = Новый HttpЗапрос("/get?p1=v1&p2=v2");
+
+	Соединение = Новый HttpСоединение(мАдресРесурса);
+	Ответ = Соединение.Получить(Запрос);
+
+	юТест.ПроверитьРавенство(200, Ответ.КодСостояния);
+
+	Ответ.ПолучитьТелоКакПоток();
+
+	юТест.ПроверитьРавенство(Ответ.ПолучитьТелоКакПоток().ДоступноЧтение, Истина);
+
+	юТест.ПроверитьРавенство(ТипЗнч(Ответ.ПолучитьТелоКакДвоичныеДанные()), Тип("ДвоичныеДанные"));
+	юТест.ПроверитьВхождение(Ответ.ПолучитьТелоКакСтроку(), """p1"": ""v1""");
+	юТест.ПроверитьВхождение(Ответ.ПолучитьТелоКакСтроку(), """p2"": ""v2""");
+
+	юТест.ПроверитьРавенство(ТипЗнч(Ответ.ПолучитьТелоКакДвоичныеДанные()), Тип("ДвоичныеДанные"));
+
+	// Оригинальный поток уже вычитан вернется поддельный
+	юТест.ПроверитьРавенство(Ответ.ПолучитьТелоКакПоток().ДоступноЧтение, Истина);
+
+КонецПроцедуры
+
+Процедура ТестДолженПроверитьПолучениеТелаПослеЗакрытогоПотока() Экспорт
+
+	Запрос = Новый HttpЗапрос("/get?p1=v1&p2=v2");
+
+	Соединение = Новый HttpСоединение(мАдресРесурса);
+	Ответ = Соединение.Получить(Запрос);
+
+	юТест.ПроверитьРавенство(200, Ответ.КодСостояния);
+
+	Поток = Ответ.ПолучитьТелоКакПоток();
+	Поток.Закрыть();
+
+	юТест.ПроверитьВхождение(Ответ.ПолучитьТелоКакСтроку(), """p2"": ""v2""");
+
+КонецПроцедуры
+
+Процедура ТестДолженПроверитьНедоступностьЧистогоПотокаПослеПолученияТела() Экспорт
+
+	Запрос = Новый HttpЗапрос("/get?p1=v1&p2=v2");
+
+	Соединение = Новый HttpСоединение(мАдресРесурса);
+	Ответ = Соединение.Получить(Запрос);
+
+	юТест.ПроверитьРавенство(200, Ответ.КодСостояния);
+
+	юТест.ПроверитьВхождение(Ответ.ПолучитьТелоКакСтроку(), """p2"": ""v2""");
+
+	// чистый поток не доступен для чтения
+	Поток = Ответ.ПолучитьТелоКакПоток(Истина);
+	юТест.ПроверитьРавенство(Поток.ДоступноЧтение, Ложь);
+
+	// оберточный нормальный
+	Поток = Ответ.ПолучитьТелоКакПоток();
+	юТест.ПроверитьРавенство(Поток.ДоступноЧтение, Истина);
+	ЧтениеДанных = Новый ЧтениеДанных(Поток);
+	юТест.ПроверитьВхождение(
+			ПолучитьСтрокуИзДвоичныхДанных(ЧтениеДанных.Прочитать().ПолучитьДвоичныеДанные()),
+			"""p2"": ""v2"""
+	);
+
 КонецПроцедуры
 
 Процедура ТестДолженПроверитьПолучениеStreamEvent() Экспорт
@@ -411,7 +481,7 @@
 	Прошло = ТекущаяУниверсальнаяДатаВМиллисекундах() - Старт;
 	ютест.ПроверитьМеньше(Прошло, 600);
 
-	ТелоПоток = Ответ.ПолучитьТелоКакПоток();
+	ТелоПоток = Ответ.ПолучитьТелоКакПоток(Истина);
 	юТест.ПроверитьТип(ТелоПоток, Тип("Поток"));
 
 	ЧтениеДанных = Новый ЧтениеДанных(ТелоПоток);
@@ -492,7 +562,7 @@
 
 КонецФункции
 
-Функция ВыбратьДоступныйХост()
+Функция ВыбратьДоступныйХост() Экспорт
 
 	// Если задана переменная окружения, используем ее при наличии значения
 	ЗначениеИзОкружения = ПолучитьПеременнуюСреды("OS_HTTP_TEST_HOST");
@@ -508,6 +578,7 @@
 	// Пробуем типовые варианты httpbin
 	Кандидаты = Новый Массив;
 	Кандидаты.Добавить("http://127.0.0.1:8085");
+	Кандидаты.Добавить("https://connectorhttp.ru");
 	Кандидаты.Добавить("https://httpbin.org");
 	Кандидаты.Добавить("https://httpbingo.org");
 

Original file line number	Diff line number	Diff line change
`@@ -23,9 +23,10 @@ class HttpResponseBody : IDisposable`
`23`	`23`	`bool _backFileIsTemp = false;`
`24`	`24`	`byte[] _inMemBody;`
`25`	`25`
`26`		`- private readonly bool _autoDecompress;`
	`26`	`+ private readonly bool _autoDecompress;`
`27`	`27`	`private long _contentSize = 0;`
`28`		`- private Stream _rawStream;`
	`28`	`+ private readonly Stream _rawStream;`
	`29`	`+ private bool _inMemoryResponseInited;`
`29`	`30`
`30`	`31`	`public HttpResponseBody(HttpWebResponse response, string dumpToFile)`
`31`	`32`	`{`
`@@ -35,69 +36,81 @@ public HttpResponseBody(HttpWebResponse response, string dumpToFile)`
`35`	`36`	`return;`
`36`	`37`	`}`
`37`	`38`
	`39`	`+ _inMemoryResponseInited = false;`
`38`	`40`	`_rawStream = response.GetResponseStream();`
`39`	`41`	`_autoDecompress = string.Equals(response.ContentEncoding, "gzip", StringComparison.OrdinalIgnoreCase);`
`40`	`42`	`_contentSize = _autoDecompress ? -1 : response.ContentLength;`
`41`	`43`
`42`	`44`	`if (!String.IsNullOrEmpty(dumpToFile))`
`43`	`45`	`{`
`44`		`- InitFileBackedResponse(response, dumpToFile);`
	`46`	`+ InitFileBackedResponse(dumpToFile);`
`45`	`47`	`}`
`46`	`48`	`else if(_autoDecompress)`
`47`	`49`	`{`
`48`		`- InitInMemoryResponse(response);`
	`50`	`+ InitInMemoryResponse();`
`49`	`51`	`}`
`50`	`52`	`}`
`51`	`53`
`52`		`- private void InitInMemoryResponse(HttpWebResponse response)`
	`54`	`+ private void InitInMemoryResponse()`
`53`	`55`	`{`
`54`	`56`	`if(_contentSize > INMEMORY_BODY_LIMIT)`
`55`	`57`	`{`
`56`	`58`	`var filename = Path.GetTempFileName();`
`57`	`59`	`_backFileIsTemp = true;`
`58`		`- InitFileBackedResponse(response, filename);`
	`60`	`+ InitFileBackedResponse(filename);`
`59`	`61`	`}`
`60`	`62`	`else`
`61`	`63`	`{`
`62`	`64`	`if(_contentSize == UNDEFINED_LENGTH)`
`63`	`65`	`{`
`64`		`- ReadToStream(response);`
	`66`	`+ ReadToStream();`
`65`	`67`	`}`
`66`	`68`	`else`
`67`	`69`	`{`
`68`		`- ReadToArray(response);`
	`70`	`+ ReadToArray();`
`69`	`71`	`}`
`70`	`72`	`}`
	`73`	`+ _inMemoryResponseInited = true;`
`71`	`74`	`}`
`72`	`75`
`73`	`76`	`public bool AutoDecompress => _autoDecompress;`
`74`	`77`
`75`	`78`	`public long ContentSize => _contentSize < 0 ? 0 : _contentSize;`
`76`	`79`
`77`		`- public Stream OpenReadStream()`
	`80`	`+ public Stream OpenReadStream(bool raw = false)`
`78`	`81`	`{`
	`82`	`+ if (raw)`
	`83`	`+ {`
	`84`	`+ return GetResponseStream();`
	`85`	`+ }`
	`86`	`+`
	`87`	`+ if (!_inMemoryResponseInited)`
	`88`	`+ {`
	`89`	`+ InitInMemoryResponse();`
	`90`	`+ }`
	`91`	`+`
`79`	`92`	`if (_backingFileName != null)`
`80`	`93`	`{`
`81`	`94`	`return new FileStream(_backingFileName, FileMode.Open, FileAccess.Read);`
`82`	`95`	`}`
`83`		`- else if (_inMemBody != null)`
`84`		`- {`
`85`		`- return new MemoryStream(_inMemBody);`
`86`		`- }`
	`96`	`+ else if (_inMemBody != null)`
	`97`	`+ {`
	`98`	`+ return new MemoryStream(_inMemBody);`
	`99`	`+ }`
`87`	`100`	`else`
`88`		`- return _rawStream;`
	`101`	`+ throw new InvalidOperationException("No response body");`
`89`	`102`	`}`
`90`	`103`
`91`		`- private Stream GetResponseStream(HttpWebResponse response)`
	`104`	`+ private Stream GetResponseStream()`
`92`	`105`	`{`
`93`	`106`	`if (_autoDecompress)`
`94`		`- return new GZipStream(response.GetResponseStream(), CompressionMode.Decompress);`
`95`		`- return response.GetResponseStream();`
	`107`	`+ return new GZipStream(_rawStream, CompressionMode.Decompress);`
	`108`	`+ return _rawStream;`
`96`	`109`	`}`
`97`		`-`
`98`		`- private void ReadToStream(HttpWebResponse response)`
	`110`	`+`
	`111`	`+ private void ReadToStream()`
`99`	`112`	`{`
`100`		`- using (var responseStream = GetResponseStream(response))`
	`113`	`+ using (var responseStream = GetResponseStream())`
`101`	`114`	`using(var ms = new MemoryStream())`
`102`	`115`	`{`
`103`	`116`	`bool memStreamIsAlive = true;`
`@@ -119,7 +132,7 @@ private void ReadToStream(HttpWebResponse response)`
`119`	`132`	`var filename = Path.GetTempFileName();`
`120`	`133`	`_backFileIsTemp = true;`
`121`	`134`	`_backingFileName = filename;`
`122`		`-`
	`135`	`+`
`123`	`136`	`ms.Position = 0;`
`124`	`137`	`using (var file = new FileStream(filename, FileMode.Create))`
`125`	`138`	`{`
`@@ -146,11 +159,11 @@ private void ReadToStream(HttpWebResponse response)`
`146`	`159`	`}`
`147`	`160`	`}`
`148`	`161`
`149`		`- private void ReadToArray(HttpWebResponse response)`
	`162`	`+ private void ReadToArray()`
`150`	`163`	`{`
`151`	`164`	`System.Diagnostics.Debug.Assert(_contentSize <= INMEMORY_BODY_LIMIT);`
`152`		`-`
`153`		`- using var stream = GetResponseStream(response);`
	`165`	`+`
	`166`	`+ using var stream = GetResponseStream();`
`154`	`167`	`var mustRead = (int)_contentSize;`
`155`	`168`	`_inMemBody = new byte[mustRead];`
`156`	`169`	`int offset = 0;`
`@@ -168,10 +181,10 @@ private void ReadToArray(HttpWebResponse response)`
`168`	`181`	`}`
`169`	`182`	`}`
`170`	`183`
`171`		`- private void InitFileBackedResponse(HttpWebResponse response, string backingFileName)`
	`184`	`+ private void InitFileBackedResponse(string backingFileName)`
`172`	`185`	`{`
`173`	`186`	`_backingFileName = backingFileName;`
`174`		`- using(var responseStream = GetResponseStream(response))`
	`187`	`+ using (var responseStream = GetResponseStream())`
`175`	`188`	`{`
`176`	`189`	`using(var file = new FileStream(backingFileName, FileMode.Create))`
`177`	`190`	`{`
`@@ -195,7 +208,7 @@ private static void StreamToStreamCopy(Stream responseStream, Stream acceptor)`
`195`	`208`
`196`	`209`	`private void Dispose(bool manualDispose)`
`197`	`210`	`{`
`198`		`- if(manualDispose)`
	`211`	`+ if (manualDispose)`
`199`	`212`	`{`
`200`	`213`	`GC.SuppressFinalize(this);`
`201`	`214`	`_inMemBody = null;`