Files
rss-generator/rss-generator/Class/CmnUtil.cs
T

983 lines
40 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.Security.Cryptography;
using System.ServiceModel.Syndication;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Text.RegularExpressions;
using System.Xml;
namespace rss_generator.Class;
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>
/// 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($"[情報] {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($"[HTTP Error] Status Code: {response.StatusCode} for {url}");
return null;
}
// 成功していれば、ストリームを読み込んで返す
return await response.Content.ReadAsStreamAsync();
}
catch (HttpRequestException ex)
{
// ネットワーク不通やタイムアウトなどの例外処理
LogManager.AddLog($"[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 response = await client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken);
response.EnsureSuccessStatusCode();
await using var stream = await response.Content.ReadAsStreamAsync(cancellationToken);
// 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 経由で対象 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;
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($"[情報] セッション {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($"[警告] {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($"[警告] 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 の 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
};
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($"[エラー] {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($"[エラー] 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 リクエスト用 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("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($"[エラー] {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($"[エラー] コマンド実行失敗 (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($"[エラー] プロセスの起動に失敗しました: {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;
}
}