public async Task Execute(IJobExecutionContext context)
{
if (!IsRunning)
{
IsRunning = true;
baseUrl = context.JobDetail.JobDataMap.Get("baseUrl").ToString();
proxyUrl = context.JobDetail.JobDataMap.Get("proxyUrl").ToString();
feedNode = context.JobDetail.JobDataMap.Get("node") as FeedNode;
Logger.GetLogger(baseUrl).Info("start feed job execute");
var task = Task.Factory.StartNew(() =>
{
var feeds = GetFeedJobs(baseUrl, proxyUrl, feedNode);
var compile = new UrlCompile();
var stpStartInfo = new STPStartInfo
{
IdleTimeout = 3000,
MaxWorkerThreads = 8,
MinWorkerThreads = 0
};
var pool = new SmartThreadPool(stpStartInfo);
var waits = new List <IWorkItemResult>();
foreach (var feed in feeds)
{
var addrs = compile.GetResult(feed.Address);
Logger.GetLogger(baseUrl).Info("compile address " + feed.Address + " result " + string.Join(",", addrs));
foreach (var addr in addrs)
{
feed.Address = addr.ToString();
var item = pool.QueueWorkItem((u) =>
{
DoTask(u, true);
}, feed);
waits.Add(item);
}
}
SmartThreadPool.WaitAll(waits.ToArray());
pool.Shutdown(true, 1000);
pool.Dispose();
pool = null;
waits.Clear();
});
await task;
IsRunning = false;
Logger.GetLogger(baseUrl).Info("end feed job execute");
}
}
public RSSListFrame_ListItemViewModel(FeedNode feed)
{
_feed = feed;
RemoveFeedCommand = new RelayCommand(() =>
{
FeedManageService.FeedManage.RemoveFeed(_feed);
Messenger.Default.Send <RSSListFrame_ListItemViewModelMsg, RSSListFrameViewModel>(
new RSSListFrame_ListItemViewModelMsg()
{
ListItem = this, MsgType = "RemoveFeedCommand"
});
});
FlushFeedCommand = new RelayCommand(() =>
{
Messenger.Default.Send <RSSListFrame_ListItemViewModelMsg, RSSContentFrameViewModel>(
new RSSListFrame_ListItemViewModelMsg()
{
ListItem = this, MsgType = "FlushFeedCommand"
});
});
SelectFeedCommand = new RelayCommand(() =>
{
Messenger.Default.Send <RSSListFrame_ListItemViewModelMsg, RSSContentFrameViewModel>(
new RSSListFrame_ListItemViewModelMsg()
{
ListItem = this, MsgType = "SelectFeedCommand"
});
});
}
private FeedNode GetFeedNode(Feed feed)
{
feed.Normalize(feed.Uri);
var node = new FeedNode(feed, _feedCache);
return(node);
}
public FeedNode AddFeed(string url, string name = null)
{
FeedNode f = _controller?.AddFeed(name ?? url, url);
Save();
return(f);
}
private List <FeedModel> GetFeedJobs(string baseUrl, string proxyUrl, FeedNode node)
{
Logger.GetLogger(baseUrl).Info("start get feed");
try
{
if (NodeConfigurationSection.Standalone)
{
var paging = new Paging();
paging.CurrentPage = _page;
paging.PageSize = 50;
var feeds = FeedLiteDb.GetAvailableFeeds(paging);
if (_page > 0 && feeds.Count == 0)
{
_page = 0;
paging.CurrentPage = _page;
feeds = FeedLiteDb.GetAvailableFeeds(paging);
}
_page++;
Logger.GetLogger(baseUrl).Info("get feed jobs:" + feeds.Count);
return(feeds);
}
else
{
var d = node.GetData("/config/feed/" + node.BaseUrl);
var config = JsonConvert.DeserializeObject <NodeConfig>(d.Data);
var pages = config.Pages == null ? "" : string.Join(",", config.Pages);
var client = new RestClient("http://" + proxyUrl);
var restRequest = new RestRequest("api/feed/job?pages=" + pages);
restRequest.Method = Method.GET;
var restResponse = client.Execute(restRequest);
var feeds = JsonConvert.DeserializeObject <List <FeedModel> >(restResponse.Content);
Logger.GetLogger(baseUrl).Info("get feed jobs:" + feeds.Count);
return(feeds);
}
}
catch (Exception ex)
{
Logger.GetLogger(baseUrl).Info("get feed error " + ex.Message);
return(new List <FeedModel>());
}
}
public static async void Start(string proxyUrl, FeedNode feedNode)
{
scheduler = await factory.GetScheduler();
await scheduler.Start();
IJobDetail job = JobBuilder.Create <FeedJob>().Build();
job.JobDataMap.Add("proxyUrl", proxyUrl);
job.JobDataMap.Add("node", feedNode);
ITrigger trigger = TriggerBuilder.Create().WithCronSchedule("0 0/1 * * * ?").Build();
await scheduler.ScheduleJob(job, trigger);
}
public async void Start(string baseUrl, FeedNode feedNode)
{
if (Schedulers.ContainsKey(baseUrl))
{
return;
}
Logger.GetLogger(baseUrl).Info(baseUrl + " feed scheduler starting");
this.baseUrl = baseUrl;
this.feedNode = feedNode;
Schedulers.Add(baseUrl, this);
Logger.GetLogger(baseUrl).Info(baseUrl + " feed scheduler started");
await SyncFeed();
AddExtractJob();
}
public void ListAll()
{
var testFeed = Fake.Feed;
var testImplementation = (Implementation)testFeed.Elements[0];
var digest1 = testImplementation.ManifestDigest;
var digest2 = new ManifestDigest(sha256New: "2");
using var tempDir = new TemporaryDirectory("0install-unit-tests");
GetMock <IFeedCache>().Setup(x => x.ListAll()).Returns(new[] { testFeed.Uri });
GetMock <IFeedCache>().Setup(x => x.GetFeed(testFeed.Uri)).Returns(testFeed);
StoreMock.Setup(x => x.ListAll()).Returns(new[] { digest1, digest2 });
StoreMock.Setup(x => x.ListAllTemp()).Returns(new string[0]);
StoreMock.Setup(x => x.GetPath(It.IsAny <ManifestDigest>())).Returns(tempDir);
FileUtils.Touch(Path.Combine(tempDir, ".manifest"));
var feedNode = new FeedNode(testFeed, Sut.FeedCache);
RunAndAssert(new ImplementationNode[] { new OwnedImplementationNode(digest1, testImplementation, feedNode, Sut.ImplementationStore), new OrphanedImplementationNode(digest2, Sut.ImplementationStore) }, ExitCode.OK);
}
private List <FeedModel> GetFeedJobs(string proxyUrl, FeedNode node)
{
try
{
var d = node.GetData("/config/feed/" + node.BaseUrl);
var config = JsonConvert.DeserializeObject <NodeConfig>(d.Data);
var pages = config.Pages == null ? "" : string.Join(",", config.Pages);
var client = new RestClient("http://" + proxyUrl);
var restRequest = new RestRequest("api/feed/job?pages=" + pages);
restRequest.Method = Method.GET;
var restResponse = client.Execute(restRequest);
var feeds = JsonConvert.DeserializeObject <List <FeedModel> >(restResponse.Content);
return(feeds);
}
catch (Exception ex)
{
return(new List <FeedModel>());
}
}
/// <summary>
/// Creates a new owned implementation node.
/// </summary>
/// <param name="digest">The digest identifying the implementation.</param>
/// <param name="implementation">Information about the implementation from a <see cref="Feed"/> file.</param>
/// <param name="parent">The node of the feed owning the implementation.</param>
/// <param name="implementationStore">The <see cref="IImplementationStore"/> the implementation is located in.</param>
/// <exception cref="FormatException">The manifest file is not valid.</exception>
/// <exception cref="IOException">The manifest file could not be read.</exception>
/// <exception cref="UnauthorizedAccessException">Read access to the file is not permitted.</exception>
public OwnedImplementationNode(ManifestDigest digest, Implementation implementation, FeedNode parent, IImplementationStore implementationStore)
: base(digest, implementationStore)
{
_parent = parent ?? throw new ArgumentNullException(nameof(parent));
_implementation = implementation ?? throw new ArgumentNullException(nameof(implementation));
}
public void RenameFeed(FeedNode feed, string name)
{
feed.name = name;
Save();
}
public void RemoveFeed(FeedNode feed)
{
_controller?.RemoveNode(feed);
Save();
}
