private static Sensor SizeOrCountSensor(TaskId taskId,
string storeType,
string storeName,
string metricName,
string metricDescription,
string descriptionOfAvg,
string descriptionOfMax,
MetricsRecordingLevel recordingLevel,
StreamMetricsRegistry streamsMetrics)
{
Sensor sensor = streamsMetrics.StoreLevelSensor(
GetThreadId(),
taskId,
storeName,
metricName,
metricDescription,
recordingLevel);
string group;
IDictionary <string, string> tags;
group = StreamMetricsRegistry.STATE_STORE_LEVEL_GROUP;
tags = streamsMetrics.StoreLevelTags(GetThreadId(), taskId.ToString(), storeName, storeType);
SensorHelper.AddAvgAndMaxToSensor(sensor, group, tags, metricName, descriptionOfAvg, descriptionOfMax);
return(sensor);
}
private static Sensor ThroughputAndLatencySensor(TaskId taskId,
string storeType,
string storeName,
string metricName,
string metricDescription,
string descriptionOfRate,
string descriptionOfAvg,
string descriptionOfMax,
MetricsRecordingLevel recordingLevel,
StreamMetricsRegistry streamsMetrics)
{
Sensor sensor;
string latencyMetricName = metricName + StreamMetricsRegistry.LATENCY_SUFFIX;
IDictionary <string, string> tags =
streamsMetrics.StoreLevelTags(GetThreadId(), taskId.ToString(), storeName, storeType);
sensor = streamsMetrics.StoreLevelSensor(GetThreadId(), taskId, storeName, metricName, metricDescription, recordingLevel);
SensorHelper.AddInvocationRateToSensor(sensor, StreamMetricsRegistry.STATE_STORE_LEVEL_GROUP, tags, metricName,
descriptionOfRate);
SensorHelper.AddAvgAndMaxToSensor(
sensor,
StreamMetricsRegistry.STATE_STORE_LEVEL_GROUP,
tags,
latencyMetricName,
descriptionOfAvg,
descriptionOfMax
);
return(sensor);
}
protected SelectSuggestionTest()
{
Workspace = Substitute.For <IDatabaseWorkspace>();
Workspace.Id.Returns(WorkspaceId);
Project = Substitute.For <IDatabaseProject>();
Project.Id.Returns(ProjectId);
Project.Name.Returns(ProjectName);
Project.Color.Returns(ProjectColor);
Project.Workspace.Returns(Workspace);
Project.WorkspaceId.Returns(WorkspaceId);
Task = Substitute.For <IDatabaseTask>();
Task.Id.Returns(TaskId);
Task.Project.Returns(Project);
Task.ProjectId.Returns(ProjectId);
Task.Name.Returns(TaskId.ToString());
TimeEntry = Substitute.For <IDatabaseTimeEntry>();
TimeEntry.Description.Returns(Description);
TimeEntry.Project.Returns(Project);
Tag = Substitute.For <IDatabaseTag>();
Tag.Id.Returns(TagId);
Tag.Name.Returns(TagName);
}
private static Sensor ThroughputSensor(string threadId,
TaskId taskId,
string processorNodeId,
string metricNamePrefix,
string metricDescription,
string descriptionOfRate,
string descriptionOfCount,
MetricsRecordingLevel recordingLevel,
StreamMetricsRegistry metricsRegistry)
{
Sensor sensor =
metricsRegistry.NodeLevelSensor(threadId, taskId, processorNodeId, metricNamePrefix, metricDescription,
recordingLevel);
var tags = metricsRegistry.NodeLevelTags(threadId, taskId.ToString(), processorNodeId);
SensorHelper.AddInvocationRateAndCountToSensor(
sensor,
StreamMetricsRegistry.PROCESSOR_NODE_LEVEL_GROUP,
tags,
metricNamePrefix,
descriptionOfRate,
descriptionOfCount
);
return(sensor);
}
public Task GetById(TaskId id)
{
var parameters = GetDefaultParameters();
parameters[HttpParameters.TaskId] = id.ToString();
return(SendRequest <Task>(HttpFunctions.TaskReads.GetTaskById, parameters));
}
public void Delete(TaskId taskId)
{
var parameters = GetDefaultParameters();
parameters[HttpParameters.TaskId] = taskId.ToString();
SendRequest(HttpFunctions.TaskEdits.DeleteTask, parameters);
}
public void Edit(TaskId oldTaskId, Task newTask)
{
var parameters = GetDefaultParameters();
parameters[HttpParameters.TaskId] = oldTaskId.ToString();
SendRequest(HttpFunctions.TaskEdits.EditTask, parameters, newTask.ToJson());
}
public Comment[] GetFromTask(TaskId taskId)
{
var parameters = GetDefaultParameters();
parameters[HttpParameters.CommentTaskId] = taskId.ToString();
return(SendRequest <Comment[]>(HttpFunctions.CommentReads.GetCommentsFromTask, parameters));
}
[U] public async Task Urls()
{
await POST($"/_reindex/{EscapeUriString(_taskId.ToString())}/_rethrottle")
.Fluent(c => c.Rethrottle(_taskId))
.Request(c => c.Rethrottle(new ReindexRethrottleRequest(_taskId)))
.FluentAsync(c => c.RethrottleAsync(_taskId))
.RequestAsync(c => c.RethrottleAsync(new ReindexRethrottleRequest(_taskId)))
;
}
public bool ProcessInputs() // todo : should be private. Fix after PackageBase fix
{
lock (_taskLock)
{
bool isProcesedNow = false;
if (!_inputsProcessed)
{
if (this.Priority == TaskPriority.Urgent && (!this.ExecParams.ContainsKey("MinTime") || !this.ExecParams.ContainsKey("MaxTime")))
{
throw new Exception("Urgent tasks should have 'MinTime' and 'MaxTime' params");
}
var inputFilesTime = TimeSpan.Zero;
Time.AddToOverheads(TaskTimeOverheads.PackageBase, () =>
{
Log.Debug("Processing inputs for task " + TaskId.ToString());
try
{
this.Params = PackageBaseProxy.UpdateInputs(this.PackageEngineState, this.Params);
this.Params = PackageBaseProxy.UpdateInputs(this.PackageEngineState, this.InputFiles);
this.Incarnation = PackageBaseProxy.ProcessInputFiles(this.PackageEngineState, out inputFilesTime);
bool expectGroups;
var expectedOutFiles = PackageBaseProxy.ListExpectedOutputs(this.PackageEngineState, out expectGroups);
this.Incarnation.ExpectedOutputFileNames = expectedOutFiles.ToArray();
this.Incarnation.CanExpectMoreFiles = expectGroups;
Log.Debug(String.Format("Expected outputs for task {2} are {0} {1}",
String.Join(", ", expectedOutFiles.Select(name => "'" + name + "'")),
expectGroups ? "with groups" : "",
TaskId
));
}
catch (Exception e)
{
_inputsProcessingError = e.Message;
Log.Error(String.Format("Error while processing inputs for task {0}: {1}", this.TaskId, e));
if (this.State == TaskState.ReadyToExecute)
{
throw;
}
}
});
Time.OverheadsSpecial["pb/inputFiles"] = inputFilesTime;
_inputsProcessed = true;
isProcesedNow = true;
}
return(isProcesedNow);
}
}
private Dictionary <string, string> CreateParametersForUsingFilters(string content, DateTime?beginCreateDateTime, DateTime?endCreateDateTime, UserId userId, TaskId taskId)
{
var parameters = GetDefaultParameters();
AddParameterIfNotNullOrEmpty(parameters, HttpParameters.CommentContent, content);
AddParameterIfNotNullOrEmpty(parameters, HttpParameters.CommentBeginCreateDateTime, beginCreateDateTime?.ToString());
AddParameterIfNotNullOrEmpty(parameters, HttpParameters.CommentEndCreateDateTime, endCreateDateTime?.ToString());
AddParameterIfNotNullOrEmpty(parameters, HttpParameters.CommentUserId, userId?.ToString());
AddParameterIfNotNullOrEmpty(parameters, HttpParameters.CommentTaskId, taskId?.ToString());
return(parameters);
}
public static Sensor ProcessSensor(string threadId, TaskId taskId, StreamMetricsRegistry metricsRegistry)
{
Sensor sensor = metricsRegistry.TaskLevelSensor(threadId, taskId, PROCESS, PROCESS_DESCRIPTION, MetricsRecordingLevel.DEBUG);
SensorHelper.AddInvocationRateAndCountToSensor(
sensor,
StreamMetricsRegistry.TASK_LEVEL_GROUP,
metricsRegistry.TaskLevelTags(threadId, taskId.ToString()),
PROCESS,
PROCESS_RATE_DESCRIPTION,
PROCESS_TOTAL_DESCRIPTION
);
return(sensor);
}
[U] public async Task Urls()
{
await POST($"/_reindex/{EscapeUriString(_taskId.ToString())}/_rethrottle")
#pragma warning disable 618 // changing method signature would be binary breaking
.Fluent(c => c.Rethrottle(f => f.TaskId(_taskId)))
#pragma warning restore 618
.Fluent(c => c.Rethrottle(_taskId))
.Request(c => c.Rethrottle(new ReindexRethrottleRequest(_taskId)))
#pragma warning disable 618 // changing method signature would be binary breaking
.FluentAsync(c => c.RethrottleAsync(f => f.TaskId(_taskId)))
#pragma warning restore 618
.FluentAsync(c => c.RethrottleAsync(_taskId))
.RequestAsync(c => c.RethrottleAsync(new ReindexRethrottleRequest(_taskId)))
;
}
public static Sensor ActiveRestorationSensor(string threadId,
TaskId taskId,
StreamMetricsRegistry metricsRegistry)
{
Sensor sensor = metricsRegistry.TaskLevelSensor(threadId, taskId, ACTIVE_RESTORATION, ACTIVE_RESTORATION_DESCRIPTION, MetricsRecordingLevel.DEBUG);
SensorHelper.AddValueMetricToSensor(
sensor,
StreamMetricsRegistry.TASK_LEVEL_GROUP,
metricsRegistry.TaskLevelTags(threadId, taskId.ToString()),
ACTIVE_RESTORATION,
ACTIVE_RESTORATION_DESCRIPTION
);
return(sensor);
}
public void Abort(Resource resource)
{
lock (_taskLock)
{
if (State == TaskState.Started)
{
State = TaskState.Aborted;
Time.AddToOverheads(TaskTimeOverheads.Provider, () =>
{
//var provider = Broker.ProviderByName(resource.ProviderName);
var controller = Discovery.GetControllerFarm(resource);
try
{
//provider.Abort(this.Incarnation.ProvidedTaskId, resource, CurrentSchedule.Nodes);
controller.Abort(this.TaskId); // service's method
controller.Close();
}
catch (Exception e)
{
controller.Abort(); // drop connection
Log.Error(String.Format("Exception while aborting task {0} on {1}: {2}",
TaskId, resource.ResourceName, e
));
}
});
Time.Finished(TaskTimeMetric.Calculation);
//Time.Finished(TaskTimeMetric.Brokering);
}
else
{
Log.Warn("Aborting non-started task " + TaskId.ToString());
State = TaskState.Aborted;
}
//todo: _lastEvent = Aborted; !!!!!!!!!!!!!!!!!!111
_failReason = "Aborted";
_lastEvent = Eventing.EventType.TaskFailed;
//Over();
Log.Info(String.Format("Task {0} aborted", TaskId));
}
}
protected void Page_Load(object sender, EventArgs e)
{
ScriptManager scriptManager = ScriptManager.GetCurrent(this.Page);
scriptManager.RegisterPostBackControl(this.gdTaskUsers);
hdnTaskID.Value = TaskId.ToString();
if (!IsPostBack)
{
String HelpHtml = UtilityBAL.Instance.GetContentSetting(JGConstant.ContentSettings.TASK_HELP_TEXT);
divHelpText.InnerHtml = Server.HtmlDecode(HelpHtml);
txtHelpTextEditor.InnerHtml = HelpHtml;
txtHelpTextEditor.Visible =
btnSaveHelpText.Visible = CommonFunction.CheckAdminMode();
}
}
internal Sensor TaskLevelSensor(
string threadId,
TaskId taskId,
string sensorName,
string description,
MetricsRecordingLevel metricsRecordingLevel,
params Sensor[] parents)
{
lock (taskLevelSensors)
{
threadId ??= UNKNOWN_THREAD;
string key = TaskSensorPrefix(threadId, taskId.ToString());
var sensor = GetSensor(taskLevelSensors, sensorName, key, description, metricsRecordingLevel, parents);
AddSensorThreadScope(threadId, sensor.Name);
return(sensor);
}
}
public static Sensor ActiveBufferedRecordsSensor(
string threadId,
TaskId taskId,
StreamMetricsRegistry metricsRegistry)
{
string name = ACTIVE_TASK_PREFIX + BUFFER_COUNT;
Sensor sensor = metricsRegistry.TaskLevelSensor(threadId, taskId, name, name, MetricsRecordingLevel.DEBUG);
SensorHelper.AddValueMetricToSensor(
sensor,
StreamMetricsRegistry.TASK_LEVEL_GROUP,
metricsRegistry.TaskLevelTags(threadId, taskId.ToString()),
name,
NUM_BUFFERED_RECORDS_DESCRIPTION
);
return(sensor);
}
public LocalSystemListViewModel()
{
try
{
_localScoreService = Resolver.Resolve <ILocalScoreService>();
_commonFun = Resolver.Resolve <ICommonFun>();
MessagingCenter.Subscribe <CommonMessage>(this, "LocalResetTaskID", (obj) =>
{
if (obj.TaskID == "-1")
{
_refresh = false;
}
else
{
_refresh = true;
}
});
MessagingCenter.Subscribe <List <LoaclItemOfTaskDto> >(this, "LocalSendSystemList", (obj) =>
{
_taskId = obj.FirstOrDefault().TPId.ToString();
Init(obj);
});
MessagingCenter.Subscribe <LocalSystemListPage>(this, "LocalRefreshSystem", (obj) =>
{
if (_refresh)
{
RefreshPage(TaskId.ToString());
}
});
ItemTappedCommand = new RelayCommand <LoaclItemOfTaskDto>(TappedCommand);
}
catch (Exception)
{
_commonFun.AlertLongText("操作异常,请重试。-->CustomizedTaskViewModel");
return;
}
}
public int GetRoomId(Context context)
{
int roomId = 0;
SQLiteOpenHelper rationalCleaningDatabaseHelper = new RationalCleaningDatabaseHelper(context);
db = rationalCleaningDatabaseHelper.ReadableDatabase;
taskCursor = db.Query("CLEANING_TASK_TABLE",
new string[] { "ROOM_ID" },
"_id = ?", new string[] { TaskId.ToString() }, null, null, null);
if (taskCursor.MoveToFirst())
{
roomId = taskCursor.GetInt(0);
}
taskCursor.Close();
db.Close();
return(roomId);
}
private static Sensor InvocationRateAndCountSensor(string threadId,
TaskId taskId,
string metricName,
string metricDescription,
string descriptionOfRate,
string descriptionOfCount,
MetricsRecordingLevel recordingLevel,
StreamMetricsRegistry streamsMetrics)
{
Sensor sensor =
streamsMetrics.TaskLevelSensor(threadId, taskId, metricName, metricDescription, recordingLevel);
SensorHelper.AddInvocationRateAndCountToSensor(
sensor,
StreamMetricsRegistry.TASK_LEVEL_GROUP,
streamsMetrics.TaskLevelTags(threadId, taskId.ToString()),
metricName,
descriptionOfRate,
descriptionOfCount
);
return(sensor);
}
public Task(TaskDescription description)
: base(description)
{
if (Priority == TaskPriority.Urgent)
{
if (!ExecParams.ContainsKey("MinTime"))
{
ExecParams["MinTime"] = "0";
}
if (!ExecParams.ContainsKey("MaxTime"))
{
ExecParams["MaxTime"] = ExecParams["MinTime"];
}
}
OutputParams = new Dictionary <string, string>();
Time = new TaskTimeMeasurement();
Time.Started(TaskTimeMetric.Postponed);
if (this.IsFake())
{
Time.Edge(started: TaskTimeMetric.Queued, finished: TaskTimeMetric.Postponed);
}
Estimations = null;
CurrentSchedule = null;
Incarnation = new IncarnationParams();
State = TaskState.Defined;
string stepName = ExecParams.ContainsKey("StepName")? ExecParams["StepName"]: null;
string storageRoot = IOProxy.Storage.BuildPath(UserId, WfId, stepId: TaskId.ToString(), stepName: stepName);
this.PackageEngineState = new PackageEngineState(description, storageRoot); // todo : measure PackageEngineState expenses
}
private static Sensor AvgAndMaxSensor(string threadId,
TaskId taskId,
string metricName,
string metricDescription,
string descriptionOfAvg,
string descriptionOfMax,
MetricsRecordingLevel recordingLevel,
StreamMetricsRegistry streamsMetrics)
{
Sensor sensor =
streamsMetrics.TaskLevelSensor(threadId, taskId, metricName, metricDescription, recordingLevel);
var tags = streamsMetrics.TaskLevelTags(threadId, taskId.ToString());
SensorHelper.AddAvgAndMaxToSensor(
sensor,
StreamMetricsRegistry.TASK_LEVEL_GROUP,
tags,
metricName,
descriptionOfAvg,
descriptionOfMax
);
return(sensor);
}
public static Sensor ExpiredWindowRecordDropSensor(TaskId taskId,
string storeType,
string storeName,
StreamMetricsRegistry streamsMetrics)
{
Sensor sensor = streamsMetrics.StoreLevelSensor(
GetThreadId(),
taskId,
storeName,
EXPIRED_WINDOW_RECORD_DROP,
EXPIRED_WINDOW_RECORD_DROP_DESCRIPTION,
MetricsRecordingLevel.INFO
);
SensorHelper.AddInvocationRateAndCountToSensor(
sensor,
"stream-" + storeType + "-metrics",
streamsMetrics.StoreLevelTags(GetThreadId(), taskId.ToString(), storeName, storeType),
EXPIRED_WINDOW_RECORD_DROP,
EXPIRED_WINDOW_RECORD_DROP_RATE_DESCRIPTION,
EXPIRED_WINDOW_RECORD_DROP_TOTAL_DESCRIPTION
);
return(sensor);
}
[U] public override async Task Urls() =>
await POST($"/_delete_by_query/{EscapeUriString(_taskId.ToString())}/_rethrottle")
.Fluent(c => c.DeleteByQueryRethrottle(_taskId))
.Request(c => c.DeleteByQueryRethrottle(new DeleteByQueryRethrottleRequest(_taskId)))
.FluentAsync(c => c.DeleteByQueryRethrottleAsync(_taskId))
.RequestAsync(c => c.DeleteByQueryRethrottleAsync(new DeleteByQueryRethrottleRequest(_taskId)));
public override string ToString() =>
$"At [{Timestamp:O}], task type [{TypeOfTask.ToString()}] associated " +
$"with command [{CommandId.ToString()}] started with unique id: [{TaskId.ToString()}]";
//Test reports of JobHistoryServer. History server should get log files from MRApp and read them
/// <exception cref="System.Exception"/>
public virtual void TestReports()
{
Configuration config = new Configuration();
config.SetClass(CommonConfigurationKeysPublic.NetTopologyNodeSwitchMappingImplKey
, typeof(TestJobHistoryParsing.MyResolver), typeof(DNSToSwitchMapping));
RackResolver.Init(config);
MRApp app = new TestJobHistoryEvents.MRAppWithHistory(1, 1, true, this.GetType().
FullName, true);
app.Submit(config);
Org.Apache.Hadoop.Mapreduce.V2.App.Job.Job job = app.GetContext().GetAllJobs().Values
.GetEnumerator().Next();
app.WaitForState(job, JobState.Succeeded);
historyServer = new JobHistoryServer();
historyServer.Init(config);
historyServer.Start();
// search JobHistory service
JobHistory jobHistory = null;
foreach (Org.Apache.Hadoop.Service.Service service in historyServer.GetServices())
{
if (service is JobHistory)
{
jobHistory = (JobHistory)service;
}
}
IDictionary <JobId, Org.Apache.Hadoop.Mapreduce.V2.App.Job.Job> jobs = jobHistory.
GetAllJobs();
NUnit.Framework.Assert.AreEqual(1, jobs.Count);
NUnit.Framework.Assert.AreEqual("job_0_0000", jobs.Keys.GetEnumerator().Next().ToString
());
Task task = job.GetTasks().Values.GetEnumerator().Next();
TaskAttempt attempt = task.GetAttempts().Values.GetEnumerator().Next();
HistoryClientService historyService = historyServer.GetClientService();
MRClientProtocol protocol = historyService.GetClientHandler();
GetTaskAttemptReportRequest gtarRequest = recordFactory.NewRecordInstance <GetTaskAttemptReportRequest
>();
// test getTaskAttemptReport
TaskAttemptId taId = attempt.GetID();
taId.SetTaskId(task.GetID());
taId.GetTaskId().SetJobId(job.GetID());
gtarRequest.SetTaskAttemptId(taId);
GetTaskAttemptReportResponse response = protocol.GetTaskAttemptReport(gtarRequest
);
NUnit.Framework.Assert.AreEqual("container_0_0000_01_000000", response.GetTaskAttemptReport
().GetContainerId().ToString());
NUnit.Framework.Assert.IsTrue(response.GetTaskAttemptReport().GetDiagnosticInfo()
.IsEmpty());
// counters
NUnit.Framework.Assert.IsNotNull(response.GetTaskAttemptReport().GetCounters().GetCounter
(TaskCounter.PhysicalMemoryBytes));
NUnit.Framework.Assert.AreEqual(taId.ToString(), response.GetTaskAttemptReport().
GetTaskAttemptId().ToString());
// test getTaskReport
GetTaskReportRequest request = recordFactory.NewRecordInstance <GetTaskReportRequest
>();
TaskId taskId = task.GetID();
taskId.SetJobId(job.GetID());
request.SetTaskId(taskId);
GetTaskReportResponse reportResponse = protocol.GetTaskReport(request);
NUnit.Framework.Assert.AreEqual(string.Empty, reportResponse.GetTaskReport().GetDiagnosticsList
().GetEnumerator().Next());
// progress
NUnit.Framework.Assert.AreEqual(1.0f, reportResponse.GetTaskReport().GetProgress(
), 0.01);
// report has corrected taskId
NUnit.Framework.Assert.AreEqual(taskId.ToString(), reportResponse.GetTaskReport()
.GetTaskId().ToString());
// Task state should be SUCCEEDED
NUnit.Framework.Assert.AreEqual(TaskState.Succeeded, reportResponse.GetTaskReport
().GetTaskState());
// For invalid jobid, throw IOException
GetTaskReportsRequest gtreportsRequest = recordFactory.NewRecordInstance <GetTaskReportsRequest
>();
gtreportsRequest.SetJobId(TypeConverter.ToYarn(JobID.ForName("job_1415730144495_0001"
)));
gtreportsRequest.SetTaskType(TaskType.Reduce);
try
{
protocol.GetTaskReports(gtreportsRequest);
NUnit.Framework.Assert.Fail("IOException not thrown for invalid job id");
}
catch (IOException)
{
}
// Expected
// test getTaskAttemptCompletionEvents
GetTaskAttemptCompletionEventsRequest taskAttemptRequest = recordFactory.NewRecordInstance
<GetTaskAttemptCompletionEventsRequest>();
taskAttemptRequest.SetJobId(job.GetID());
GetTaskAttemptCompletionEventsResponse taskAttemptCompletionEventsResponse = protocol
.GetTaskAttemptCompletionEvents(taskAttemptRequest);
NUnit.Framework.Assert.AreEqual(0, taskAttemptCompletionEventsResponse.GetCompletionEventCount
());
// test getDiagnostics
GetDiagnosticsRequest diagnosticRequest = recordFactory.NewRecordInstance <GetDiagnosticsRequest
>();
diagnosticRequest.SetTaskAttemptId(taId);
GetDiagnosticsResponse diagnosticResponse = protocol.GetDiagnostics(diagnosticRequest
);
// it is strange : why one empty string ?
NUnit.Framework.Assert.AreEqual(1, diagnosticResponse.GetDiagnosticsCount());
NUnit.Framework.Assert.AreEqual(string.Empty, diagnosticResponse.GetDiagnostics(0
));
}
[U] public override async Task Urls() =>
await UrlTester.POST($"/_update_by_query/{UrlTester.EscapeUriString(_taskId.ToString())}/_rethrottle")
.Fluent(c => c.UpdateByQueryRethrottle(_taskId))
.Request(c => c.UpdateByQueryRethrottle(new UpdateByQueryRethrottleRequest(_taskId)))
.FluentAsync(c => c.UpdateByQueryRethrottleAsync(_taskId))
.RequestAsync(c => c.UpdateByQueryRethrottleAsync(new UpdateByQueryRethrottleRequest(_taskId)));
public Task GetTaskStatus(TaskId task)
{
string url = String.Format("{0}/getTaskStatus?TaskId={1}", ServerUrl, Uri.EscapeDataString(task.ToString()));
WebRequest request = WebRequest.Create(url);
SetupGetRequest(url, request);
XDocument response = PerformRequest(request);
Task serverTask = ServerXml.GetTaskStatus(response);
return serverTask;
}
public void WriteXml(System.Xml.XmlWriter writer)
{
var s = new XmlSerializer(typeof(string));
var b = new XmlSerializer(typeof(bool));
var l = new XmlSerializer(typeof(List <AutoAnswer>));
writer.WriteStartElement("TaskInfo");
//taskid
writer.WriteStartElement("TaskId");
s.Serialize(writer, TaskId.ToString());
writer.WriteEndElement();
//pluginname
writer.WriteStartElement("PluginName");
s.Serialize(writer, PluginName);
writer.WriteEndElement();
//url
writer.WriteStartElement("Url");
s.Serialize(writer, Url);
writer.WriteEndElement();
//title
writer.WriteStartElement("Title");
s.Serialize(writer, Title);
writer.WriteEndElement();
//status
writer.WriteStartElement("Status");
DownloadStatus tmpds = Status;
if (tmpds == DownloadStatus.正在下载 || tmpds == DownloadStatus.正在停止 || tmpds == DownloadStatus.等待开始)
{
tmpds = DownloadStatus.已经停止;
}
s.Serialize(writer, tmpds.ToString());
writer.WriteEndElement();
//createtime
writer.WriteStartElement("CreateTime");
s.Serialize(writer, CreateTime.ToString());
writer.WriteEndElement();
//finishtime
if (FinishTime != null)
{
writer.WriteStartElement("FinishTime");
s.Serialize(writer, FinishTime.ToString());
writer.WriteEndElement();
}
//savedirectory
writer.WriteStartElement("SaveDirectory");
s.Serialize(writer, SaveDirectory.ToString());
writer.WriteEndElement();
//PartCount
writer.WriteStartElement("PartCount");
s.Serialize(writer, PartCount.ToString());
writer.WriteEndElement();
//CurrentPart
writer.WriteStartElement("CurrentPart");
s.Serialize(writer, CurrentPart.ToString());
writer.WriteEndElement();
//is be added
writer.WriteStartElement("IsBeAdded");
b.Serialize(writer, IsBeAdded);
writer.WriteEndElement();
//partialfinished
writer.WriteStartElement("PartialFinished");
b.Serialize(writer, PartialFinished);
writer.WriteEndElement();
//partialfinished detail
writer.WriteStartElement("PartialFinishedDetail");
s.Serialize(writer, PartialFinishedDetail);
writer.WriteEndElement();
//autoanswer
writer.WriteStartElement("AutoAnswers");
l.Serialize(writer, AutoAnswer);
writer.WriteEndElement();
//extract cache
writer.WriteStartElement("ExtractCache");
b.Serialize(writer, ExtractCache);
writer.WriteEndElement();
//FilePath
writer.WriteStartElement("Files");
foreach (string item in FilePath)
{
writer.WriteStartElement("File");
s.Serialize(writer, item);
writer.WriteEndElement();
}
writer.WriteEndElement();
//SubFilePath
writer.WriteStartElement("SubFiles");
foreach (string item in SubFilePath)
{
writer.WriteStartElement("SubFile");
s.Serialize(writer, item);
writer.WriteEndElement();
}
writer.WriteEndElement();
//DownloadType
writer.WriteStartElement("DownloadType");
s.Serialize(writer, DownloadTypes.ToString("D"));
writer.WriteEndElement();
//proxy
XmlSerializer sProxy = new XmlSerializer(typeof(AcDownProxy));
writer.WriteStartElement("Proxy");
sProxy.Serialize(writer, new AcDownProxy().FromWebProxy(Proxy));
writer.WriteEndElement();
//source url
writer.WriteStartElement("SourceUrl");
s.Serialize(writer, SourceUrl);
writer.WriteEndElement();
//comment
writer.WriteStartElement("Comment");
s.Serialize(writer, Comment);
writer.WriteEndElement();
//hash
writer.WriteStartElement("Hash");
s.Serialize(writer, Hash);
writer.WriteEndElement();
//Progress
writer.WriteStartElement("Progress");
s.Serialize(writer, GetProgress().ToString());
writer.WriteEndElement();
//settings
XmlSerializer sSettings = new XmlSerializer(typeof(SerializableDictionary <string, string>));
writer.WriteStartElement("Settings");
sSettings.Serialize(writer, Settings);
writer.WriteEndElement();
writer.WriteEndElement();
}
/// <summary>
/// 设置自定义json配置文件
/// </summary>
/// <param name="filePath">json文件的相对地址</param>
protected void SetConfigurationFile(string filePath)
{
if (string.IsNullOrEmpty(filePath) || !filePath.EndsWith(".json"))
{
return;
}
var builder = new ConfigurationBuilder()
.SetBasePath($"{Directory.GetCurrentDirectory()}\\wwwroot\\plugins\\{TaskId.ToString()}\\".Replace('\\', Path.DirectorySeparatorChar))
.AddJsonFile(filePath, optional: false, reloadOnChange: true);
Configuration = builder.Build();
}
