public async Task <IActionResult> Get([FromRoute] GetLogRequest request, [FromQuery] string q)
{
IActionResult result = null;
List <LogEntry> logs = null;
if (string.IsNullOrEmpty(q))
{
logs = await Server.Get(request.Application, request.DateFrom, request.DateTo, request.Page, request.Count);
}
else
{
logs = await Server.Search(request.Application, request.DateFrom, request.DateTo, q, request.Page, request.Count);
}
if (logs != null)
{
result = Factory.CreateSuccessResponse(logs);
}
else
{
result = Factory.CreateNoContentResponse();
}
return(result);
}
public Response GetLog(GetLogRequest request)
{
var retval = new Response();
try
{
var logFilePath = @"C:\Logs\" + request.LogName;
using (StreamReader sr = new StreamReader(logFilePath))
{
string line;
while ((line = sr.ReadLine()) != null)
{
retval = new GetLogResponseOK(line);
}
}
return(retval);
}
catch (Exception ex)
{
if (ex.HResult == -2147024894)
{
return(new GetLogNotExistResponse());
}
return(new AppResponseError(ex.Message));
}
}
public async Task <ActionResult> GetLog(int battleId)
{
var request = new GetLogRequest {
BattleId = battleId
};
var result = await _mediator.Send(request);
return(ProcessResult(result));
}
public RepeatedField <Event.EventLog> GetLog(uint deviceID, uint startEventID, uint maxNumOfLog)
{
var request = new GetLogRequest {
DeviceID = deviceID, StartEventID = startEventID, MaxNumOfLog = maxNumOfLog
};
var response = eventClient.GetLog(request);
return(response.Events);
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetLogRequest, GetLogResponse> ForLog(GetLogRequest request, WaiterConfiguration config, params LogLifecycleState[] targetStates)
{
var agent = new WaiterAgent <GetLogRequest, GetLogResponse>(
request,
request => client.GetLog(request),
response => targetStates.Contains(response.Log.LifecycleState.Value)
);
return(new Waiter <GetLogRequest, GetLogResponse>(config, agent));
}
public Response <GetLogResult> GetLog(GetLogRequest requestObject)
{
JObject request = JObject.FromObject(requestObject);
var result = Method(Functions.GetLog, request, ParameterValidator.GetLogCheckRequest);
try
{
var response = JsonConvert.DeserializeObject <Response <GetLogResult> >(result.ToString());
return(response);
}
catch (Exception e)
{
return(Response <GetLogResult> .BuildResponse(e));
}
}
public override async Task <GetLogResponse> GetLog(GetLogRequest request, ServerCallContext context)
{
Metadata md = context.RequestHeaders;
foreach (var entry in md)
{
Console.WriteLine(entry.Key + ": " + entry.Value);
}
var mes = await db.GetLog(Guid.Parse(request.Guid));
return(new GetLogResponse()
{
Log = mes
});
}
public Response GetLog(GetLogRequest request)
{
try
{
var ds = _dal.GetLog(request.LogName);
var tbl = ds.Tables[0];
var retval = new Response();
if (tbl.Rows.Count == 1)
{
retval = new GetLogResponseOK((string)tbl.Rows[0][0]);
}
return(retval);
}
catch (Exception ex)
{
return(new AppResponseError(ex.Message));
}
}
private void HandleOutput(GetLogRequest request)
{
var waiterConfig = new WaiterConfiguration
{
MaxAttempts = MaxWaitAttempts,
GetNextDelayInSeconds = (_) => WaitIntervalSeconds
};
switch (ParameterSetName)
{
case LifecycleStateParamSet:
response = client.Waiters.ForLog(request, waiterConfig, WaitForLifecycleState).Execute();
break;
case Default:
response = client.GetLog(request).GetAwaiter().GetResult();
break;
}
WriteOutput(response, response.Log);
}
private static async Task GetLog(LoggingManagementClient client, string logGroupId, string logId)
{
GetLogRequest getLogRequest = new GetLogRequest
{
LogGroupId = logGroupId,
LogId = logId
};
logger.Info("Getting log Details for this Log");
logger.Info("=============");
GetLogResponse getLogResponse = await client.GetLog(getLogRequest);
Log log = getLogResponse.Log;
logger.Info($"Name:{log.DisplayName}");
logger.Info($"Log ID:{log.Id}");
logger.Info($"Log Group ID:{log.LogGroupId}");
logger.Info($"Log Lifecycle State:{log.LifecycleState}");
logger.Info($"Time Created:{log.TimeCreated}");
logger.Info($"Time Last Modified:{log.TimeLastModified}");
logger.Info($"Retention Duration:{log.RetentionDuration} days");
}
protected override void ProcessRecord()
{
base.ProcessRecord();
GetLogRequest request;
try
{
request = new GetLogRequest
{
LogGroupId = LogGroupId,
LogId = LogId,
OpcRequestId = OpcRequestId
};
HandleOutput(request);
FinishProcessing(response);
}
catch (Exception ex)
{
TerminatingErrorDuringExecution(ex);
}
}
public string Get(GetLogRequest req)
{
// open the debug.log file
var file_path = "./debug.log";
string output = "";
if (!File.Exists(file_path))
{
return("");
}
// TODO: f*****g log4net locks exclusive, can't even read a file we are only
// appending to.
var fs = new FileStream(file_path, FileMode.Open, FileAccess.Read);
var reader = new StreamReader(fs);
var content = reader.ReadToEnd();
// only give back last 500 lines
var logs = content.Skip(content.Length - 500).ToList();
logs.ForEach(s => output += s + "\n");
return(output);
}
/// <summary>
/// Creates a waiter using default wait configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetLogRequest, GetLogResponse> ForLog(GetLogRequest request, params LogLifecycleState[] targetStates)
{
return(this.ForLog(request, WaiterConfiguration.DefaultWaiterConfiguration, targetStates));
}
public IAsyncResult BeginGetLog(GetLogRequest requestObject)
{
JObject request = JObject.FromObject(requestObject);
return(BeginMethod(Functions.GetLog, request, ParameterValidator.GetLogCheckRequest, GetLogCallBackMethod));
}
public Response GetLog([FromBody] GetLogRequest request)
{
var serviceCreated = _service.Create(request.LogType);
return(serviceCreated.GetLog(request));
}
