Files
rss-generator/rss-generator/Class/Common/CmnUtil.cs
T
armonica c788acaeca feat(momonga): フィード著者にアーティスト(作者)およびサークルの値を追加しFreshRSSでの個別検索に対応
- momonga_fanzine.cs, momonga_magazine.cs において本文メタデータから「サークル」「作者」を抽出し、著者の箇所(Authors)にそれぞれ追加
- 複数作者や複数サークルがある場合はカンマ区切りで個別登録し、重複を排除
- FreshRSS上でサークル名・アーティスト名のそれぞれで絞り込み検索が可能になるよう改善
- リファクタリングおよびログ出力プレフィックスの統一
2026-10-28 11:32:45 +09:00

1436 lines
60 KiB
C#
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
using AngleSharp;
using AngleSharp.Dom;
using AngleSharp.Html.Parser;
using PuppeteerSharp;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Net;
using System.Net.Http.Headers;
using System.Net.Http.Json;
using System.Collections.Concurrent;
using System.Security.Cryptography;
using System.ServiceModel.Syndication;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using System.Xml;
namespace rss_generator.Class.Common;
public class CmnUtil
{
/// <summary>
/// XMLファイルの出力先パスを取得
/// </summary>
/// <param name="fileName"></param>
/// <returns></returns>
public static string GetExportXmlPath(string fileName = "", string addDir = "")
{
string outputDir = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "output", addDir);
// 出力先フォルダがなければ自動作成する(ローカル・VPS両方の対策)
if (!Directory.Exists(outputDir))
{
Directory.CreateDirectory(outputDir);
}
// 出力するファイル名を決定
string filePath = fileName != "" ? Path.Combine(outputDir, fileName) : outputDir;
return filePath;
}
/// <summary>
/// 例外発生箇所からポストバックのイベントハンドラまでの呼び出し履歴を出力します
/// </summary>
public static void PrintCallStackToEvent(Exception ex)
{
#if DEBUG
// 1. 現在のスレッドの実行スタック全体を取得 (PDB情報を含む)
StackTrace st = new StackTrace(true);
StackFrame[] frames = st.GetFrames();
if (frames == null || frames.Length == 0) return;
Debug.Print("================================================================================");
Debug.Print(string.Format("[例外種別] {0}", ex != null ? ex.GetType().FullName : "Unknown Exception"));
Debug.Print(string.Format("[エラー内容] {0}", ex != null ? ex.Message.Trim() : "なし"));
Debug.Print("--------------------------------------------------------------------------------");
Debug.Print("【呼び出し経路】");
List<StackFrame> userFrames = new List<StackFrame>();
foreach (StackFrame frame in frames)
{
var method = frame.GetMethod();
if (method == null) continue;
var declaringType = method.DeclaringType;
var typeFullName = (declaringType != null ? declaringType.FullName : "") ?? "";
// ASP.NET 内部のパイプラインに到達したら、それより上位(IIS内部)は除外して打ち切り
if (typeFullName.StartsWith("System.Web.") || typeFullName.StartsWith("System.Web.UI."))
{
break;
}
userFrames.Add(frame);
}
// 時系列順に並び替える
userFrames.Reverse();
for (int i = 0; i < userFrames.Count; i++)
{
StackFrame frame = userFrames[i];
var method = frame.GetMethod();
var declaringType = method != null ? method.DeclaringType : null;
string className = declaringType != null ? declaringType.Name : "Unknown";
string methodName = method != null ? method.Name : "";
if (methodName == "PrintCallStackToEvent")
{
continue;
}
var fileName = frame.GetFileName();
int lineNumber = frame.GetFileLineNumber();
string fileInfo = "";
if (!string.IsNullOrEmpty(fileName) && lineNumber > 0)
{
fileInfo = string.Format(" ({0} : {1} 行目)", Path.GetFileName(fileName), lineNumber);
}
Debug.Print($"-> {className}.{methodName}{fileInfo}");
}
Debug.Print("================================================================================");
#endif
}
/// <summary>
/// ファイル出力
/// </summary>
/// <param name="fileName"></param>
/// <param name="contents"></param>
public static void ExportFile(string fileName, string? contents)
{
var filePath = GetExportXmlPath(fileName);
// ファイル書き出し
File.WriteAllText(filePath, contents);
}
/// <summary>
/// 記事が指定の日時以降(カットオフ以降)の取得対象であるかを判定します。
/// 公開日時がカットオフ前であっても、更新日時がカットオフ以降であれば取得対象となります。
/// </summary>
/// <param name="item">判定対象のフィードアイテム</param>
/// <param name="cutoff">カットオフ日時</param>
/// <returns>取得対象であれば true、24時間以上前で対象外であれば false</returns>
public static bool IsItemWithinCutoff(SyndicationItem item, DateTimeOffset cutoff)
{
bool hasUpdated = item.LastUpdatedTime > DateTimeOffset.MinValue;
bool hasPublished = item.PublishDate > DateTimeOffset.MinValue;
// 1. 更新日時が有効で、カットオフ以降であれば対象(公開日時が24時間以上前でも救済)
if (hasUpdated && item.LastUpdatedTime >= cutoff)
{
return true;
}
// 2. 公開日時が有効で、カットオフ以降であれば対象
if (hasPublished && item.PublishDate >= cutoff)
{
return true;
}
// 3. 公開日時または更新日時のいずれかが設定されているが、どちらもカットオフ未満(古い)場合は除外
if (hasUpdated || hasPublished)
{
return false;
}
// 4. 日時情報が一切存在しないアイテム(MinValue)は念のため残す
return true;
}
/// <summary>
/// フィードアイテム一覧から、指定時間以内(デフォルト24時間)の対象アイテムのみを抽出します。
/// 公開日時が指定時間以上前であっても、更新日時が指定時間以内であれば抽出対象となります。
/// </summary>
/// <param name="items">アイテム一覧</param>
/// <param name="hours">許容時間(時間単位、デフォルト: 24時間)</param>
/// <returns>条件を満たすアイテムのリスト</returns>
public static List<SyndicationItem> FilterItemsWithinHours(IEnumerable<SyndicationItem> items, double hours = 24)
{
var cutoff = DateTimeOffset.Now.AddHours(-hours);
return items.Where(item => IsItemWithinCutoff(item, cutoff)).ToList();
}
/// <summary>
/// 全ての RSS 出力処理において、記事内の画像(img src / video poster)を自動で Base64 形式(Data URI)に変換して埋め込むかどうか。
/// 環境変数 EMBED_ALL_IMAGES_BASE64 (true/false) での上書きも可能です。
/// </summary>
public static bool EmbedAllImagesBase64
{
get
{
var envVal = Environment.GetEnvironmentVariable("EMBED_ALL_IMAGES_BASE64");
if (!string.IsNullOrWhiteSpace(envVal) && bool.TryParse(envVal, out var parsed))
{
return parsed;
}
return _embedAllImagesBase64;
}
set => _embedAllImagesBase64 = value;
}
private static bool _embedAllImagesBase64 = true;
/// <summary>
/// 画像URLから画像データを取得し、Base64 (Data URI: data:{mime};base64,{data}) 形式の文字列として返します。
/// サイト固有の Referer ヘッダーの自動付与やタイムアウト(6秒)制御を行います。
/// </summary>
public static async Task<string?> FetchImageAsBase64Async(HttpClient client, string imageUrl, int timeoutSeconds = 6)
{
if (string.IsNullOrWhiteSpace(imageUrl)) return null;
if (imageUrl.StartsWith("data:", StringComparison.OrdinalIgnoreCase)) return imageUrl;
var targetUrl = imageUrl.Trim();
// // で始まるスキーム相対URLを https: に補完
if (targetUrl.StartsWith("//"))
{
targetUrl = "https:" + targetUrl;
}
// HTML エンティティの多重エンコード(&amp; や &amp;amp; など)を完全に解決
while (targetUrl.Contains("&amp;", StringComparison.OrdinalIgnoreCase))
{
targetUrl = WebUtility.HtmlDecode(targetUrl);
}
if (!targetUrl.StartsWith("http://", StringComparison.OrdinalIgnoreCase) && !targetUrl.StartsWith("https://", StringComparison.OrdinalIgnoreCase)) return null;
try
{
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(timeoutSeconds));
using var request = new HttpRequestMessage(HttpMethod.Get, targetUrl);
// User-Agent の設定
request.Headers.Add("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36");
// ドメインに応じた適切な Referer の自動判定と付与
if (Uri.TryCreate(targetUrl, UriKind.Absolute, out var uri))
{
var host = uri.Host.ToLowerInvariant();
if (host.Contains("pximg.net") || host.Contains("pixiv"))
{
request.Headers.Referrer = new Uri("https://www.pixiv.net/");
}
else if (host.Contains("hitomi.la") || host.Contains("gold-usergeneratedcontent.net"))
{
request.Headers.Referrer = new Uri("https://hitomi.la/");
}
else if (host.Contains("ci-en.dlsite.com"))
{
request.Headers.Referrer = new Uri("https://ci-en.dlsite.com/");
}
else if (host.Contains("momon-ga.com"))
{
request.Headers.Referrer = new Uri("https://momon-ga.com/");
}
else
{
request.Headers.Referrer = new Uri($"{uri.Scheme}://{uri.Authority}/");
}
}
using var response = await client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cts.Token);
if (!response.IsSuccessStatusCode)
{
return null;
}
// 2MB 以上の画像はメモリ保護のためスキップ(元のURLを参照させる)
if (response.Content.Headers.ContentLength.HasValue && response.Content.Headers.ContentLength.Value > 2 * 1024 * 1024)
{
return null;
}
var contentType = response.Content.Headers.ContentType?.MediaType;
if (string.IsNullOrWhiteSpace(contentType) || !contentType.StartsWith("image/", StringComparison.OrdinalIgnoreCase))
{
contentType = "image/jpeg";
}
var bytes = await response.Content.ReadAsByteArrayAsync(cts.Token);
if (bytes == null || bytes.Length == 0) return null;
var base64 = Convert.ToBase64String(bytes);
return $"data:{contentType};base64,{base64}";
}
catch
{
// タイムアウトや取得失敗時は元のURLのままフォールバックするため静かにnull返却
return null;
}
}
/// <summary>
/// SyndicationFeed に含まれる全記事(24時間フィルタ適用後)の HTML 本文から画像 URL を抽出し、
/// 並列ダウンロードして Base64 形式(Data URI)に置換します。
/// </summary>
public static async Task EmbedImagesAsBase64InFeedAsync(SyndicationFeed feed, HttpClient client, int maxParallel = 2)
{
if (feed.Items == null) return;
var itemsList = feed.Items.ToList();
if (itemsList.Count == 0) return;
// 1. 全アイテムの HTML から画像 URL を抽出(重複排除)
var urlPattern = new Regex(@"(?:<img\b[^>]*?\bsrc=[""'](?<url>[^""'\s>]+)[""']|<video\b[^>]*?\bposter=[""'](?<url>[^""'\s>]+)[""'])", RegexOptions.IgnoreCase | RegexOptions.Compiled);
// rawUrl -> decodedUrl のマッピング
var targetUrls = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
foreach (var item in itemsList)
{
var html = item.Summary?.Text ?? (item.Content as TextSyndicationContent)?.Text;
if (string.IsNullOrWhiteSpace(html)) continue;
var matches = urlPattern.Matches(html);
foreach (Match match in matches)
{
var rawUrl = match.Groups["url"].Value;
if (!string.IsNullOrWhiteSpace(rawUrl) && !rawUrl.StartsWith("data:", StringComparison.OrdinalIgnoreCase))
{
var decoded = rawUrl;
while (decoded.Contains("&amp;", StringComparison.OrdinalIgnoreCase))
{
decoded = WebUtility.HtmlDecode(decoded);
}
if (decoded.StartsWith("//"))
{
decoded = "https:" + decoded;
}
targetUrls[rawUrl] = decoded;
}
}
}
if (targetUrls.Count == 0) return;
// 2. 並列ダウンロードして Base64 辞書を構築(メモリ節約のため同時並行数は2に制御)
var cacheMap = new ConcurrentDictionary<string, string>(StringComparer.OrdinalIgnoreCase);
using var semaphore = new SemaphoreSlim(maxParallel);
var downloadTasks = targetUrls.Select(async kvp =>
{
var rawUrl = kvp.Key;
var fetchUrl = kvp.Value;
await semaphore.WaitAsync();
try
{
var dataUri = await FetchImageAsBase64Async(client, fetchUrl);
if (!string.IsNullOrWhiteSpace(dataUri))
{
cacheMap[rawUrl] = dataUri;
cacheMap[fetchUrl] = dataUri;
}
}
finally
{
semaphore.Release();
}
});
await Task.WhenAll(downloadTasks);
// 3. 各アイテムの HTML 内の画像 URL を Base64 文字列に置換
if (cacheMap.Count > 0)
{
foreach (var item in itemsList)
{
if (item.Summary != null && !string.IsNullOrWhiteSpace(item.Summary.Text))
{
var newHtml = item.Summary.Text;
bool modified = false;
foreach (var kvp in cacheMap)
{
if (newHtml.Contains(kvp.Key, StringComparison.OrdinalIgnoreCase))
{
newHtml = newHtml.Replace(kvp.Key, kvp.Value, StringComparison.OrdinalIgnoreCase);
modified = true;
}
}
if (modified)
{
item.Summary = new TextSyndicationContent(newHtml, TextSyndicationContentKind.Html);
}
}
}
}
int distinctSuccess = targetUrls.Keys.Count(k => cacheMap.ContainsKey(k));
LogManager.AddLog($"[情報] [CmnUtil] 画像の Base64 変換完了: {distinctSuccess}/{targetUrls.Count} 件成功 (記事数: {itemsList.Count})");
// 使用済みメモリの即時解放
cacheMap.Clear();
targetUrls.Clear();
}
/// <summary>
/// Feed を非同期でファイルに出力します。画像 Base64 変換が有効な場合は自動で変換を行います(Pixiv のみ有効)。
/// </summary>
/// <param name="fileName">出力先ファイル名</param>
/// <param name="feed">SyndicationFeed</param>
/// <param name="client">画像ダウンロード用 HttpClient</param>
/// <param name="addDir">サブディレクトリ</param>
/// <param name="embedBase64">画像を Base64 変換するかどうか(Pixiv 以外は false)</param>
/// <param name="filter24Hours">24時間以上前の古い記事を除外するかどうか(デフォルト: true)</param>
public static async Task ExportXMLFileAsync(string fileName, SyndicationFeed feed, HttpClient? client = null, string addDir = "", bool embedBase64 = false, bool filter24Hours = true)
{
// 24時間以上前の古い記事を除外
if (filter24Hours && feed.Items != null)
{
feed.Items = FilterItemsWithinHours(feed.Items, 24);
}
// 画像の Base64 埋め込み処理
if (embedBase64 && EmbedAllImagesBase64 && client != null)
{
try
{
await EmbedImagesAsBase64InFeedAsync(feed, client);
}
catch (Exception ex)
{
LogManager.AddLog($"[警告] [CmnUtil] 画像 Base64 変換中に例外発生 ({fileName}): {ex.Message}");
}
}
var filePath = GetExportXmlPath(fileName, addDir);
var settings = new XmlWriterSettings
{
Encoding = new UTF8Encoding(false), // BOMなしUTF-8
Indent = true,
Async = true
};
using var xmlWriter = XmlWriter.Create(filePath, settings);
var formatter = new Rss20FeedFormatter(feed);
formatter.WriteTo(xmlWriter);
int count = feed.Items?.Count() ?? 0;
string displayFileName = System.IO.Path.GetFileName(filePath);
LogManager.AddLog($"[情報] 【CmnUtil】 {displayFileName} を正常に出力しました (記事数: {count})");
}
/// <summary>
/// Feedをファイルとして出力(同期版・後方互換用)
/// </summary>
/// <param name="fileName"></param>
/// <param name="feed"></param>
public static void ExportXMLFile(string fileName, SyndicationFeed feed, string addDir = "")
{
// 24時間以上前の古い記事を除外(公開日時が24時間以上前でも、更新日時が24時間以内なら取得対象)
if (feed.Items != null)
{
feed.Items = FilterItemsWithinHours(feed.Items, 24);
}
var filePath = GetExportXmlPath(fileName, addDir);
// 文字コードをUTF-8に指定
var settings = new XmlWriterSettings
{
Encoding = new UTF8Encoding(false), // BOMなしUTF-8
Indent = true
};
using var xmlWriter = XmlWriter.Create(filePath, settings);
// RSS 2.0 形式でファイルに直接出力
var formatter = new Rss20FeedFormatter(feed);
formatter.WriteTo(xmlWriter);
int count = feed.Items?.Count() ?? 0;
string displayFileName = System.IO.Path.GetFileName(filePath);
LogManager.AddLog($"[情報] 【CmnUtil】 {displayFileName} を正常に出力しました (記事数: {count})");
}
/// <summary>
/// 指定したURLのストリームを安全に取得します。404などのエラー時はnullを返します。
/// </summary>
public static async Task<Stream?> GetStreamSafeAsync(HttpClient client, string url)
{
if (string.IsNullOrWhiteSpace(url)) return null;
try
{
// HttpRequestMessageを作成
var request = new HttpRequestMessage(HttpMethod.Get, url);
// ResponseHeadersRead を指定することで、ヘッダーを読み込んだ直後に制御が戻る(一瞬で判定できる)
var response = await client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead);
// 404 や 500 などのエラーではないか(成功ステータス 200~299 か)チェック
if (!response.IsSuccessStatusCode)
{
// 404の場合などのログをここに書くことも可能
//AddLog($"[HTTP Error] Status Code: {response.StatusCode} for {url}");
LogManager.AddLog($"[エラー] 【CmnUtil】 HTTP Error Status Code: {response.StatusCode} for {url}");
return null;
}
// 成功していれば、ストリームを読み込んで返す
return await response.Content.ReadAsStreamAsync();
}
catch (HttpRequestException ex)
{
// ネットワーク不通やタイムアウトなどの例外処理
LogManager.AddLog($"[エラー] 【CmnUtil】 Network Error {ex.Message}");
return null;
}
catch (Exception)
{
return null;
}
}
/// <summary>
/// 直接HTTP通信により対象URLのHTMLを取得し、AngleSharpのIDocumentを生成して返します。
/// ストリーム直接パース、並列アクセスセーフ、メモリリーク防止、高速化を施しています。
/// </summary>
/// <param name="client">HttpClient インスタンス</param>
/// <param name="pageURL">取得対象のWebページURL</param>
/// <param name="useCacheBuster">キャッシュ回避用パラメータ(_tutc)を付与するかどうか(デフォルト: true)</param>
/// <param name="cancellationToken">キャンセレーショントークン</param>
/// <returns>AngleSharpのIDocument</returns>
public static async Task<IDocument> GetDocument(
HttpClient client,
string pageURL,
bool useCacheBuster = true,
CancellationToken cancellationToken = default)
{
Console.WriteLine($"Fetching: {pageURL}");
// 1. リクエストURLの構築(キャッシュ回避パラメータ付与)
string requestUrl = pageURL;
if (useCacheBuster)
{
string separator = pageURL.Contains('?') ? "&" : "?";
requestUrl = $"{pageURL}{separator}_tutc={DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()}";
}
using var request = new HttpRequestMessage(HttpMethod.Get, requestUrl);
// 2. キャッシュ制御ヘッダー
request.Headers.CacheControl = new CacheControlHeaderValue
{
NoCache = true,
NoStore = true,
MustRevalidate = true
};
request.Headers.Pragma.ParseAdd("no-cache");
// 3. User-Agent(クライアント側に未設定の場合のみリクエスト単位で設定し、共有clientの競合を防止)
if (!client.DefaultRequestHeaders.UserAgent.Any() && !request.Headers.UserAgent.Any())
{
request.Headers.UserAgent.ParseAdd("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36");
}
// 4. Accept ヘッダー
if (!client.DefaultRequestHeaders.Accept.Any() && !request.Headers.Accept.Any())
{
request.Headers.Accept.ParseAdd("text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8");
}
// 5. ストリームによるレスポンス受信と直接パース(ResponseHeadersRead で中間バッファリングと巨大文字列生成を排除)
using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
linkedCts.CancelAfter(TimeSpan.FromSeconds(15)); // ハング防止の最大15秒タイムアウト
using var response = await client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, linkedCts.Token);
// 403 Forbidden が返された場合は自動的に FlareSolverr 経由で取得
if (response.StatusCode == HttpStatusCode.Forbidden)
{
LogManager.AddLog($"[情報] [CmnUtil] 403 Forbidden を検知したため、FlareSolverr 経由で取得します: {pageURL}");
return await GetDocumentFlareSolverr(client, pageURL);
}
response.EnsureSuccessStatusCode();
await using var stream = await response.Content.ReadAsStreamAsync(linkedCts.Token);
// Content-Type (charset 等) を取得して AngleSharp に通知
var contentType = response.Content.Headers.ContentType?.ToString();
// 6. AngleSharp の軽量コンテキスト生成とストリーム直接パース
var config = Configuration.Default;
var context = BrowsingContext.New(config);
IDocument document = await context.OpenAsync(req =>
{
req.Content(stream);
req.Address(pageURL); // 基準URLは元のpageURLに設定
if (!string.IsNullOrEmpty(contentType))
{
req.Header("Content-Type", contentType);
}
}, cancellationToken);
return document;
}
#region FlareSolverr 連携
/// <summary>
/// FlareSolverr 用の JSON シリアライズオプション(静的インスタンスとしてキャッシュしメモリ浪費を防止)
/// </summary>
private static readonly JsonSerializerOptions FlareSolverrJsonOptions = new()
{
PropertyNameCaseInsensitive = true,
DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull
};
/// <summary>
/// FlareSolverr への同時アクセスによる過負荷・Chromium競合・クラッシュを防止するためのセマフォ(直列化)
/// </summary>
private static readonly SemaphoreSlim FlareSolverrSemaphore = new(1, 1);
/// <summary>
/// アプリケーション全体で共有・使い回す FlareSolverr セッションID
/// </summary>
public static string? SharedFlareSolverrSessionId { get; set; }
/// <summary>
/// FlareSolverr 経由で対象 URL の HTML を取得し、AngleSharp の IDocument を生成して返します。
/// 排他制御および最大3回の自動リトライ(セッション無効化フォールバック・待機付き)を備えています。
/// </summary>
/// <param name="client">HttpClient インスタンス</param>
/// <param name="pageURL">取得対象のWebページURL</param>
/// <param name="flareSolverrEndpoint">FlareSolverrのエンドポイントURL(デフォルト: https://udukipc-flaresolverr.armonica-vps.work/v1)</param>
/// <param name="maxTimeout">FlareSolverr側の最大タイムアウトミリ秒(デフォルト: 60000ms)</param>
/// <param name="session">セッションID(セッションを再利用して高速化する場合に指定)</param>
/// <returns>AngleSharpのIDocument</returns>
public static async Task<IDocument> GetDocumentFlareSolverr(
HttpClient client,
string pageURL,
string flareSolverrEndpoint = "https://udukipc-flaresolverr.armonica-vps.work/v1",
int maxTimeout = 60000,
string? session = null)
{
await FlareSolverrSemaphore.WaitAsync();
try
{
const int maxRetries = 3;
string? currentSession = session ?? SharedFlareSolverrSessionId;
for (int attempt = 1; attempt <= maxRetries; attempt++)
{
Console.WriteLine($"Fetching via FlareSolverr (試行 {attempt}/{maxRetries}): {pageURL}");
var payload = new FlareSolverrRequest
{
Cmd = "request.get",
Url = pageURL,
MaxTimeout = maxTimeout,
Session = currentSession
};
using var request = new HttpRequestMessage(HttpMethod.Post, flareSolverrEndpoint)
{
Content = JsonContent.Create(payload, options: FlareSolverrJsonOptions)
};
try
{
using var response = await client.SendAsync(request);
var responseContent = await response.Content.ReadAsStringAsync();
if (!response.IsSuccessStatusCode)
{
LogManager.AddLog($"[警告] FlareSolverr HTTP失敗 (Status: {(int)response.StatusCode} {response.ReasonPhrase}, URL: {pageURL}, Detail: {responseContent})");
// セッション不整合による500の可能性があるため、次回はセッションなしでリトライ
if (currentSession != null)
{
LogManager.AddLog($"[情報] 【CmnUtil】 セッション {currentSession} を解除して次回セッションなしで再試行します。");
currentSession = null;
}
if (attempt < maxRetries)
{
await Task.Delay(attempt * 2500);
continue;
}
throw new HttpRequestException($"FlareSolverr サーバーエラー (Status: {(int)response.StatusCode}, Detail: {responseContent})");
}
var flareResponse = JsonSerializer.Deserialize<FlareSolverrResponse>(responseContent, FlareSolverrJsonOptions);
if (flareResponse == null)
{
throw new InvalidOperationException($"FlareSolverr レスポンスのデシリアライズ失敗: {pageURL}");
}
if (!string.Equals(flareResponse.Status, "ok", StringComparison.OrdinalIgnoreCase))
{
string errorMsg = $"FlareSolverr エラー (Status: {flareResponse.Status}, Message: {flareResponse.Message}): {pageURL}";
LogManager.AddLog($"[警告] 【CmnUtil】 {errorMsg}");
if (attempt < maxRetries)
{
currentSession = null;
await Task.Delay(attempt * 2500);
continue;
}
throw new InvalidOperationException(errorMsg);
}
string htmlContent = flareResponse.Solution?.Response ?? string.Empty;
if (string.IsNullOrWhiteSpace(htmlContent))
{
Console.WriteLine($"Warning: FlareSolverr から取得した HTML が空です ({pageURL})");
}
var config = Configuration.Default;
var context = BrowsingContext.New(config);
IDocument document = await context.OpenAsync(req => req.Content(htmlContent).Address(pageURL));
return document;
}
catch (Exception ex) when (attempt < maxRetries && ex is not OperationCanceledException)
{
LogManager.AddLog($"[警告] 【CmnUtil】 FlareSolverr リクエスト再試行 (試行 {attempt}/{maxRetries}, URL: {pageURL}): {ex.Message}");
currentSession = null;
await Task.Delay(attempt * 2500);
}
}
throw new InvalidOperationException($"FlareSolverr での取得が最大試行回数 ({maxRetries}回) を超えて失敗しました: {pageURL}");
}
finally
{
FlareSolverrSemaphore.Release();
}
}
/// <summary>
/// FlareSolverr 経由で対象 URL のレスポンス文字列(HTML または JSON)を取得します。
/// Chromium が JSON を表示した際の &lt;pre&gt;...&lt;/pre&gt; ラップも自動検出してアンラップ・HTMLデコードします。
/// </summary>
/// <param name="client">HttpClient インスタンス</param>
/// <param name="url">取得対象のURL</param>
/// <param name="flareSolverrEndpoint">FlareSolverrのエンドポイントURL(デフォルト: https://udukipc-flaresolverr.armonica-vps.work/v1)</param>
/// <param name="maxTimeout">FlareSolverr側の最大タイムアウトミリ秒(デフォルト: 60000ms)</param>
/// <param name="session">セッションID(セッションを再利用して高速化する場合に指定)</param>
/// <returns>レスポンス文字列(失敗時は null または空文字)</returns>
public static async Task<string?> GetStringFlareSolverr(
HttpClient client,
string url,
string flareSolverrEndpoint = "https://udukipc-flaresolverr.armonica-vps.work/v1",
int maxTimeout = 60000,
string? session = null)
{
await FlareSolverrSemaphore.WaitAsync();
try
{
const int maxRetries = 3;
string? currentSession = session ?? SharedFlareSolverrSessionId;
for (int attempt = 1; attempt <= maxRetries; attempt++)
{
Console.WriteLine($"Fetching String via FlareSolverr (試行 {attempt}/{maxRetries}): {url}");
var payload = new FlareSolverrRequest
{
Cmd = "request.get",
Url = url,
MaxTimeout = maxTimeout,
Session = currentSession
};
using var request = new HttpRequestMessage(HttpMethod.Post, flareSolverrEndpoint)
{
Content = JsonContent.Create(payload, options: FlareSolverrJsonOptions)
};
try
{
using var response = await client.SendAsync(request);
var responseContent = await response.Content.ReadAsStringAsync();
if (!response.IsSuccessStatusCode)
{
LogManager.AddLog($"[警告] FlareSolverr HTTP失敗 (Status: {(int)response.StatusCode} {response.ReasonPhrase}, URL: {url}, Detail: {responseContent})");
if (currentSession != null)
{
LogManager.AddLog($"[情報] 【CmnUtil】 セッション {currentSession} を解除して次回セッションなしで再試行します。");
currentSession = null;
}
if (attempt < maxRetries)
{
await Task.Delay(attempt * 2500);
continue;
}
throw new HttpRequestException($"FlareSolverr サーバーエラー (Status: {(int)response.StatusCode}, Detail: {responseContent})");
}
var flareResponse = JsonSerializer.Deserialize<FlareSolverrResponse>(responseContent, FlareSolverrJsonOptions);
if (flareResponse == null)
{
throw new InvalidOperationException($"FlareSolverr レスポンスのデシリアライズ失敗: {url}");
}
if (!string.Equals(flareResponse.Status, "ok", StringComparison.OrdinalIgnoreCase))
{
string errorMsg = $"FlareSolverr エラー (Status: {flareResponse.Status}, Message: {flareResponse.Message}): {url}";
LogManager.AddLog($"[警告] 【CmnUtil】 {errorMsg}");
if (attempt < maxRetries)
{
currentSession = null;
await Task.Delay(attempt * 2500);
continue;
}
throw new InvalidOperationException(errorMsg);
}
string rawContent = flareResponse.Solution?.Response ?? string.Empty;
// Chromium が JSON を表示した際の <pre>...</pre> をアンラップ
var match = Regex.Match(rawContent, @"<pre[^>]*>(.*?)</pre>", RegexOptions.Singleline | RegexOptions.IgnoreCase);
if (match.Success)
{
return WebUtility.HtmlDecode(match.Groups[1].Value).Trim();
}
return rawContent;
}
catch (Exception ex) when (attempt < maxRetries && ex is not OperationCanceledException)
{
LogManager.AddLog($"[警告] 【CmnUtil】 FlareSolverr リクエスト再試行 (試行 {attempt}/{maxRetries}, URL: {url}): {ex.Message}");
currentSession = null;
await Task.Delay(attempt * 2500);
}
}
throw new InvalidOperationException($"FlareSolverr での取得が最大試行回数 ({maxRetries}回) を超えて失敗しました: {url}");
}
finally
{
FlareSolverrSemaphore.Release();
}
}
/// <summary>
/// FlareSolverr 経由で対象 URL の RSS/Atom フィードを取得し、SyndicationItem のコレクションを返します。
/// メモリ割り当ての最小化およびストリーム直接デシリアライズにより、メモリリーク防止と高速化を行っています。
/// </summary>
/// <param name="client">HttpClient インスタンス</param>
/// <param name="url">取得対象のフィードURL</param>
/// <param name="flareSolverrEndpoint">FlareSolverrのエンドポイントURL(デフォルト: https://udukipc-flaresolverr.armonica-vps.work/v1)</param>
/// <param name="maxTimeout">FlareSolverr側の最大タイムアウトミリ秒(デフォルト: 60000ms)</param>
/// <param name="session">セッションID(セッションを再利用して高速化する場合に指定)</param>
/// <returns>SyndicationItem のコレクション</returns>
public static async Task<IEnumerable<SyndicationItem>> GetFeedItemsFlareSolverr(
HttpClient client,
string url,
string flareSolverrEndpoint = "https://udukipc-flaresolverr.armonica-vps.work/v1",
int maxTimeout = 60000,
string? session = null)
{
Console.WriteLine($"Fetching Feed via FlareSolverr: {url}");
var payload = new FlareSolverrRequest
{
Cmd = "request.get",
Url = url,
MaxTimeout = maxTimeout,
Session = session ?? SharedFlareSolverrSessionId
};
using var request = new HttpRequestMessage(HttpMethod.Post, flareSolverrEndpoint)
{
Content = JsonContent.Create(payload, options: FlareSolverrJsonOptions)
};
try
{
// レスポンスヘッダー受信時点で制御を戻し、ストリームから直接デシリアライズしてメモリ消費を抑制
using var response = await client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead);
response.EnsureSuccessStatusCode();
using var responseStream = await response.Content.ReadAsStreamAsync();
var flareResponse = await JsonSerializer.DeserializeAsync<FlareSolverrResponse>(responseStream, FlareSolverrJsonOptions);
if (flareResponse == null)
{
throw new InvalidOperationException($"FlareSolverr からのレスポンスのデシリアライズに失敗しました: {url}");
}
if (!string.Equals(flareResponse.Status, "ok", StringComparison.OrdinalIgnoreCase))
{
string errorMsg = $"FlareSolverr エラー (Status: {flareResponse.Status}, Message: {flareResponse.Message}): {url}";
LogManager.AddLog($"[エラー] 【CmnUtil】 {errorMsg}");
throw new InvalidOperationException(errorMsg);
}
string xmlContent = flareResponse.Solution?.Response ?? string.Empty;
if (string.IsNullOrWhiteSpace(xmlContent))
{
Console.WriteLine($"Warning: FlareSolverr から取得したフィード内容が空です ({url})");
return Enumerable.Empty<SyndicationItem>();
}
// FlareSolverr(Chromium)がXMLをレンダリングして <pre>...</pre> で返してきた場合のアンラップ処理
if (xmlContent.TrimStart().StartsWith("<html", StringComparison.OrdinalIgnoreCase))
{
var parser = new HtmlParser();
var doc = parser.ParseDocument(xmlContent);
var pre = doc.QuerySelector("pre");
if (pre != null && !string.IsNullOrWhiteSpace(pre.TextContent))
{
xmlContent = pre.TextContent;
}
}
using var stringReader = new StringReader(xmlContent);
using var xmlReader = XmlReader.Create(stringReader);
var feed = SyndicationFeed.Load(xmlReader);
return feed?.Items ?? Enumerable.Empty<SyndicationItem>();
}
catch (Exception ex)
{
LogManager.AddLog($"[エラー] 【CmnUtil】 FlareSolverr フィード {url} の取得に失敗: {ex.Message}");
PrintCallStackToEvent(ex);
return Enumerable.Empty<SyndicationItem>();
}
}
/// <summary>
/// FlareSolverr の新規セッションを作成します。セッションを再利用することで2回目以降のリクエストが大幅に高速化します。
/// </summary>
/// <param name="client">HttpClient インスタンス</param>
/// <param name="session">セッションID(省略時はFlareSolverr側で自動生成)</param>
/// <param name="flareSolverrEndpoint">FlareSolverrのエンドポイントURL</param>
/// <returns>作成されたセッションID</returns>
public static async Task<string?> CreateFlareSolverrSession(HttpClient client, string? session = null, string flareSolverrEndpoint = "https://udukipc-flaresolverr.armonica-vps.work/v1")
{
var payload = new FlareSolverrRequest
{
Cmd = "sessions.create",
Session = session
};
using var request = new HttpRequestMessage(HttpMethod.Post, flareSolverrEndpoint)
{
Content = JsonContent.Create(payload, options: FlareSolverrJsonOptions)
};
using var response = await client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead);
response.EnsureSuccessStatusCode();
using var responseStream = await response.Content.ReadAsStreamAsync();
var flareResponse = await JsonSerializer.DeserializeAsync<FlareSolverrResponse>(responseStream, FlareSolverrJsonOptions);
return flareResponse?.Session;
}
/// <summary>
/// FlareSolverr のセッションを破棄します。
/// </summary>
/// <param name="client">HttpClient インスタンス</param>
/// <param name="session">破棄対象のセッションID</param>
/// <param name="flareSolverrEndpoint">FlareSolverrのエンドポイントURL</param>
/// <returns>破棄が成功したかどうか</returns>
public static async Task<bool> DestroyFlareSolverrSession(
HttpClient client,
string session,
string flareSolverrEndpoint = "https://udukipc-flaresolverr.armonica-vps.work/v1")
{
if (string.IsNullOrWhiteSpace(session)) return false;
var payload = new FlareSolverrRequest
{
Cmd = "sessions.destroy",
Session = session
};
using var request = new HttpRequestMessage(HttpMethod.Post, flareSolverrEndpoint)
{
Content = JsonContent.Create(payload, options: FlareSolverrJsonOptions)
};
using var response = await client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead);
response.EnsureSuccessStatusCode();
using var responseStream = await response.Content.ReadAsStreamAsync();
var flareResponse = await JsonSerializer.DeserializeAsync<FlareSolverrResponse>(responseStream, FlareSolverrJsonOptions);
return string.Equals(flareResponse?.Status, "ok", StringComparison.OrdinalIgnoreCase);
}
/// <summary>
/// FlareSolverr に存在するすべてのセッションを取得します。
/// </summary>
public static async Task<List<string>> ListFlareSolverrSessions(
HttpClient client,
string flareSolverrEndpoint = "https://udukipc-flaresolverr.armonica-vps.work/v1")
{
try
{
var payload = new FlareSolverrRequest { Cmd = "sessions.list" };
using var request = new HttpRequestMessage(HttpMethod.Post, flareSolverrEndpoint)
{
Content = JsonContent.Create(payload, options: FlareSolverrJsonOptions)
};
using var response = await client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead);
if (!response.IsSuccessStatusCode) return new List<string>();
using var responseStream = await response.Content.ReadAsStreamAsync();
var flareResponse = await JsonSerializer.DeserializeAsync<FlareSolverrResponse>(responseStream, FlareSolverrJsonOptions);
return flareResponse?.Sessions ?? new List<string>();
}
catch (Exception ex)
{
LogManager.AddLog($"[警告] [CmnUtil] FlareSolverr セッション一覧取得失敗: {ex.Message}");
return new List<string>();
}
}
/// <summary>
/// FlareSolverr に存在するすべてのセッション(孤立・残留セッション含む)を破棄し、Chromium プロセスを終了させます。
/// </summary>
public static async Task DestroyAllFlareSolverrSessions(
HttpClient client,
string flareSolverrEndpoint = "https://udukipc-flaresolverr.armonica-vps.work/v1")
{
try
{
var sessions = await ListFlareSolverrSessions(client, flareSolverrEndpoint);
if (sessions.Count == 0) return;
LogManager.AddLog($"[情報] [CmnUtil] FlareSolverr 残留セッション ({sessions.Count} 件) の一括破棄を開始します");
foreach (var s in sessions)
{
try
{
await DestroyFlareSolverrSession(client, s, flareSolverrEndpoint);
}
catch (Exception ex)
{
LogManager.AddLog($"[警告] [CmnUtil] セッション破棄失敗 ({s}): {ex.Message}");
}
}
LogManager.AddLog($"[情報] [CmnUtil] FlareSolverr 全セッションの破棄完了");
}
catch (Exception ex)
{
LogManager.AddLog($"[警告] [CmnUtil] 全セッション破棄処理中にエラー: {ex.Message}");
}
}
/// <summary>
/// FlareSolverr リクエスト用 DTO
/// </summary>
private sealed class FlareSolverrRequest
{
[JsonPropertyName("cmd")]
public string Cmd { get; set; } = "request.get";
[JsonPropertyName("url")]
[JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
public string? Url { get; set; }
[JsonPropertyName("maxTimeout")]
[JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
public int? MaxTimeout { get; set; }
[JsonPropertyName("session")]
[JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
public string? Session { get; set; }
}
/// <summary>
/// FlareSolverr レスポンス用 DTO
/// </summary>
private sealed class FlareSolverrResponse
{
[JsonPropertyName("status")]
public string Status { get; set; } = string.Empty;
[JsonPropertyName("message")]
public string Message { get; set; } = string.Empty;
[JsonPropertyName("session")]
public string? Session { get; set; }
[JsonPropertyName("sessions")]
public List<string>? Sessions { get; set; }
[JsonPropertyName("solution")]
public FlareSolverrSolution? Solution { get; set; }
[JsonPropertyName("startTimestamp")]
public long? StartTimestamp { get; set; }
[JsonPropertyName("endTimestamp")]
public long? EndTimestamp { get; set; }
[JsonPropertyName("version")]
public string? Version { get; set; }
}
/// <summary>
/// FlareSolverr 解決結果用 DTO
/// </summary>
private sealed class FlareSolverrSolution
{
[JsonPropertyName("url")]
public string? Url { get; set; }
[JsonPropertyName("status")]
public int Status { get; set; }
[JsonPropertyName("response")]
public string? Response { get; set; }
[JsonPropertyName("userAgent")]
public string? UserAgent { get; set; }
}
#endregion
public static async Task<IEnumerable<SyndicationItem>> GetFeedItems(HttpClient client, string url)
{
try
{
using var stream = await client.GetStreamAsync(url);
using var reader = XmlReader.Create(stream);
var feed = SyndicationFeed.Load(reader);
return feed?.Items ?? Enumerable.Empty<SyndicationItem>();
}
catch (Exception ex)
{
LogManager.AddLog($"[エラー] 【CmnUtil】 {url} の取得に失敗: {ex.Message}");
return Enumerable.Empty<SyndicationItem>();
}
}
/// <summary>
/// IDocumentの取得
/// </summary>
/// <param name="pageURL"></param>
/// <returns></returns>
public static async Task<IDocument> GetDocumentRunJS(HttpClient client, string pageURL)
{
#if DEBUG
Console.WriteLine($"{pageURL}");
#endif
string wsEndpoint = "ws://browserless:3000";
// 1. Browserless に WebSocket 接続
var options = new ConnectOptions { BrowserWSEndpoint = wsEndpoint };
using var browser = await Puppeteer.ConnectAsync(options);
using var page = await browser.NewPageAsync();
// 2. リクエスト遮断(画像・CSS・フォントを無効化して高速化・省メモリ化)
await page.SetRequestInterceptionAsync(true);
page.Request += (sender, e) =>
{
var type = e.Request.ResourceType;
if (type == ResourceType.Image ||
type == ResourceType.StyleSheet ||
type == ResourceType.Font ||
type == ResourceType.Media)
{
e.Request.AbortAsync();
}
else
{
e.Request.ContinueAsync();
}
};
// 3. 対象ページへ移動
string targetUrl = "https://example.com/article/123";
await page.GoToAsync(targetUrl, new NavigationOptions
{
WaitUntil = new[] { WaitUntilNavigation.DOMContentLoaded }
});
// 4. <article> タグの出現を待機して取得
try
{
await page.WaitForSelectorAsync("article", new WaitForSelectorOptions { Timeout = 5000 });
}
catch (WaitTaskTimeoutException) { /* タイムアウト処理 */ }
string rawArticleHtml = await page.EvaluateExpressionAsync<string>(
"document.querySelector('article') ? document.querySelector('article').outerHTML : ''"
);
var parser = new HtmlParser();
var document = parser.ParseDocument(rawArticleHtml);
return document;
}
public static string GetLastPathPart(string urlStr)
{
if (Uri.TryCreate(urlStr, UriKind.Absolute, out Uri? uri))
{
// uri.AbsolutePath は "/path/to/page.html" を返す
string absolutePath = uri!.AbsolutePath;
// 末尾のスラッシュを除去した上で、スラッシュで分割して最後の要素を取得
string lastPart = absolutePath.TrimEnd('/').Split('/').LastOrDefault()!;
return lastPart ?? string.Empty;
}
return string.Empty;
}
public static string GetHtmlWithoutJavaScript(IElement originalElement)
{
if (originalElement == null) return string.Empty;
// 元のDOMツリーに影響を与えないよう、要素をディープコピー(複製)します
var element = (IElement)originalElement.Clone(true);
// クラス名の削除
foreach (var el in element.QuerySelectorAll("[class]"))
{
el.RemoveAttribute("class");
}
// 1. <script> タグの削除
var scriptTags = element.QuerySelectorAll("script").ToList();
foreach (var script in scriptTags)
{
script.Remove();
}
// 2. href="javascript:..." リンクの無効化(オプション)
var jsLinks = element.QuerySelectorAll("a[href^='javascript:' i]").ToList();
foreach (var link in jsLinks)
{
// リンクを無効化するか、href属性自体を削除します
link.SetAttribute("href", "#");
// link.RemoveAttribute("href");
}
// 3. インラインイベントハンドラ(onclick, onload など)の削除(オプション)
// ルート要素自身と、その配下の全要素を対象にします
var allElements = new[] { element }.Concat(element.QuerySelectorAll("*"));
foreach (var el in allElements)
{
// "on" で始まる属性名をリストアップ
var onAttributes = el.Attributes
.Where(attr => attr.Name.StartsWith("on", System.StringComparison.OrdinalIgnoreCase))
.Select(attr => attr.Name)
.ToList();
// 抽出した属性を削除
foreach (var attrName in onAttributes)
{
el.RemoveAttribute(attrName);
}
}
// 結果を文字列として返す
// 要素自身のタグ(<div>...</div>など)を含める場合は OuterHtml
// 要素の中身のHTMLだけが必要な場合は InnerHtml を使用してください
var fromHtml = element.OuterHtml;
var toHtml = Regex.Replace(fromHtml, @"\s+", " ");
return toHtml;
}
public static DateTime? GetPublishedTimeAsJst(IDocument document)
{
// 1. CSSセレクタを使用して該当のmetaタグを特定
var metaElement = document.QuerySelector("meta[property='article:published_time']");
if (metaElement == null)
{
return null; // 要素が見つからない場合
}
// 2. content属性の値を取得
string contentValue = metaElement.GetAttribute("content")!;
if (string.IsNullOrEmpty(contentValue))
{
return null;
}
// 3. DateTimeOffset型としてパース(時差情報を維持するため)
if (DateTimeOffset.TryParse(contentValue, out DateTimeOffset parsedOffset))
{
// 4. 日本時間(UTC+9時間)のオフセットに変換
DateTimeOffset jstOffset = parsedOffset.ToOffset(TimeSpan.FromHours(9));
// 5. DateTime型(KindはUnspecifiedまたはLocal扱い)として戻す
return jstOffset.DateTime;
}
return null; // パースに失敗した場合
}
public static DateTime? GetModifiedTimeAsJst(IDocument document)
{
// 1. CSSセレクタを使用して該当のmetaタグを特定
var metaElement = document.QuerySelector("meta[property='article:modified_time']");
if (metaElement == null)
{
return null; // 要素が見つからない場合
}
// 2. content属性の値を取得
string contentValue = metaElement.GetAttribute("content")!;
if (string.IsNullOrEmpty(contentValue))
{
return null;
}
// 3. DateTimeOffset型としてパース(時差情報を維持するため)
if (DateTimeOffset.TryParse(contentValue, out DateTimeOffset parsedOffset))
{
// 4. 日本時間(UTC+9時間)のオフセットに変換
DateTimeOffset jstOffset = parsedOffset.ToOffset(TimeSpan.FromHours(9));
// 5. DateTime型(KindはUnspecifiedまたはLocal扱い)として戻す
return jstOffset.DateTime;
}
return null; // パースに失敗した場合
}
/// <summary>
/// 【推奨】URLからDB安全な16進数ハッシュ値(64文字)を生成します。
/// 生成される文字は [0-9a-f] のみのため、DBエラーを起こす文字は一切含まれません。
/// </summary>
public static string CreateGuid(string? url)
{
if (string.IsNullOrEmpty(url))
{
return Guid.NewGuid().ToString();
}
byte[] inputBytes = Encoding.UTF8.GetBytes(url);
using (SHA512 sha = SHA512.Create())
{
byte[] hashBytes = sha.ComputeHash(inputBytes);
// 16進数文字列(小文字64文字)に変換
var sb = new StringBuilder();
foreach (byte b in hashBytes)
{
sb.Append(b.ToString("x2")); // "x2" で2桁の16進数小文字に変換
}
return sb.ToString();
}
}
/// <summary>
/// 外部プロセス(Linuxコマンド等)を実行するヘルパーメソッド
/// </summary>
public static async Task RunCommandAsync(string command, string arguments, string workingDirectory)
{
var psi = new ProcessStartInfo
{
FileName = command,
Arguments = arguments,
WorkingDirectory = workingDirectory,
RedirectStandardOutput = true,
RedirectStandardError = true,
UseShellExecute = false,
CreateNoWindow = true
};
using var process = new Process { StartInfo = psi };
if (process.Start())
{
// デッドロック防止のため、標準出力と標準エラーを平行して非同期で読み取る
Task<string> outputTask = process.StandardOutput.ReadToEndAsync();
Task<string> errorTask = process.StandardError.ReadToEndAsync();
await Task.WhenAll(outputTask, errorTask);
await process.WaitForExitAsync();
string output = (await outputTask).Trim();
string error = (await errorTask).Trim();
if (process.ExitCode != 0)
{
// エラー時は StandardError と StandardOutput の両方をログに出力する
LogManager.AddLog($"[エラー] 【CmnUtil】 コマンド実行失敗 (ExitCode: {process.ExitCode}, Cmd: {command} {arguments})\n" +
$"STDERR: {(string.IsNullOrEmpty(error) ? "(なし)" : error)}\n" +
$"STDOUT: {(string.IsNullOrEmpty(output) ? "(なし)" : output)}");
}
else
{
if (!string.IsNullOrWhiteSpace(output))
{
LogManager.AddLog($"[情報] コマンド処理完了:{command}");
}
}
}
else
{
LogManager.AddLog($"[エラー] 【CmnUtil】 プロセスの起動に失敗しました: {command}");
}
}
/// <summary>
/// 現在時刻から見て「次の指定分(秒・ミリ秒は0)」の DateTime を計算する
/// </summary>
public static DateTime GetNextTargetTime(DateTime now, int[] targetMinutes)
{
// 昇順にソート(例: [0, 30])
var sortedMinutes = targetMinutes.OrderBy(m => m).ToArray();
// 同一時間(現在の Hour)内で、現在時刻より未来の「分」を探す
foreach (int m in sortedMinutes)
{
DateTime candidate = new DateTime(now.Year, now.Month, now.Day, now.Hour, m, 0, 0, now.Kind);
if (candidate > now)
{
return candidate;
}
}
// 現在の Hour 内に未来の指定分がない場合、次の時間の最初の指定分を返す
DateTime nextHour = now.AddHours(1);
return new DateTime(nextHour.Year, nextHour.Month, nextHour.Day, nextHour.Hour, sortedMinutes[0], 0, 0, now.Kind);
}
/// <summary>
/// 相対URLの場合、絶対URLに解決する
/// </summary>
/// <param name="baseUri"></param>
/// <param name="relUri"></param>
/// <returns></returns>
public static Uri? GetAbsoluteUri(Uri? baseUri, string? relUri)
{
// 相対URLの場合、絶対URLに解決する
if (Uri.TryCreate(baseUri, relUri, out var absoluteUri))
{
return absoluteUri;
}
return null;
}
}