public async Task <bool> TryHandle(HttpListenerContext context, WriteResponseDelegate writeResponse)
{
if (context.Request.RawUrl.EndsWith(".status"))
{
// verify that the service implement IHealthStatus
var serviceName = context.Request.RawUrl.Substring(1, context.Request.RawUrl.LastIndexOf(".", StringComparison.Ordinal) - 1);
var serviceType = ServiceEndPointDefinition.ServiceNames.FirstOrDefault(o => o.Value == $"I{serviceName}").Key;
if (serviceType == null)
{
throw new RequestException("Invalid service name");
}
if (ServiceInterfaceMapper.HealthStatusServiceType == null || serviceType.IsAssignableFrom(ServiceInterfaceMapper.HealthStatusServiceType) == false)
{
await writeResponse(string.Empty).ConfigureAwait(false);
}
else
{
var healthStatusResult = await CheckServiceHealth().ConfigureAwait(false);
var status = healthStatusResult.IsHealthy ? HttpStatusCode.OK : HttpStatusCode.InternalServerError;
var json = healthStatusResult.Message;
await writeResponse(json, status).ConfigureAwait(false);
}
return(true);
}
return(false);
}
public async Task <bool> TryHandle(HttpListenerContext context, WriteResponseDelegate writeResponse)
{
if (context.Request.Url.AbsolutePath == "/config")
{
var format = context.Request.QueryString["format"] ?? "text";
switch (format)
{
case "json":
var json = _responseBuilder.BuildJson();
await writeResponse(json).ConfigureAwait(false);
break;
default:
var text = _responseBuilder.BuildText();
await writeResponse(text, contentType : "text/plain").ConfigureAwait(false);
break;
}
return(true);
}
return(false);
}
public async Task <bool> TryHandle(HttpListenerContext context, WriteResponseDelegate writeResponse)
{
var microdotHostingConfig = _microdotHostingConfigFactory();
foreach (var statusEndpoint in microdotHostingConfig.StatusEndpoints)
{
if (context.Request.Url.AbsolutePath.Equals(statusEndpoint, StringComparison.InvariantCultureIgnoreCase))
{
if (microdotHostingConfig.ShouldLogStatusEndpoint)
{
_logger.Info(log =>
{
log("Status", unencryptedTags: new Tags
{
{ "RemoteIP", context?.Request?.RemoteEndPoint?.Address?.ToString() ?? "0" },
{ "RemotePort", context?.Request?.RemoteEndPoint?.Port.ToString() }
});
});
}
await writeResponse(string.Empty).ConfigureAwait(false);
return(true);
}
}
return(false);
}
private static WritableBuffer WriteResponse(WriteResponseDelegate writeResponse, IPipeConnection connection, Buffer <byte> requestBuffer)
{
HttpRequestSingleSegment parsedRequest = HttpRequestSingleSegment.Parse(requestBuffer.Span);
// Writing directly to pooled buffers
var output = connection.Output.Alloc();
writeResponse(parsedRequest, output);
return(output);
}
public async Task <bool> TryHandle(HttpListenerContext context, WriteResponseDelegate writeResponse)
{
if (context.Request.Url.AbsolutePath.EndsWith("/schema"))
{
await writeResponse(_jsonSchema).ConfigureAwait(false);
return(true);
}
return(false);
}
/// <summary>
/// Get parsed result of request
/// </summary>
/// <returns>Object for Write response in streaming <see cref="IFlyWriterBody"/></returns>
public override IFlyWriterBody GetResult()
{
try
{
IDataMessageManager dmb = MappingConfiguration.DataFactory(this.VersionTypeResp);
dmb.Concepts = this.RetrievalManagerObject.GetAllConceptsImpl();
Builder = new DataMessageObjectBuilder()
{
MessageType = this.MessageType,
_versionTypeResp = this.VersionTypeResp,
_retrievalManager = this.RetrievalManagerObject,
};
if (VersionTypeResp == SdmxSchemaEnumType.VersionTwoPointOne && this.WhereStatement != null)
{
Builder.DimensionAtObservation = this.WhereStatement.DimensionAtObservation;
if (!string.IsNullOrEmpty(Builder.DimensionAtObservation))
{
IConceptObjectImpl DimAtObs = dmb.Concepts.Find(c => c.Id.Trim().ToUpper() == Builder.DimensionAtObservation);
if (DimAtObs != null && DimAtObs is IDimensionConcept &&
((IDimensionConcept)DimAtObs).DimensionType != DimensionTypeEnum.Time && DimAtObs.Id != "AllDimensions")
{
throw new SdmxException(this, FlyExceptionObject.FlyExceptionTypeEnum.NotImplemented, new Exception("DimensionAtObservation can be only TIME_PERIOD or AllDimensions"));
}
}
}
if (this.WhereStatement.IsRest)
{
this.WhereStatement.BuildRestQuery(this.RetrievalManagerObject);
}
WriteResponseDelegate callback = new WriteResponseDelegate(Builder.WriteDataMessage);
return(dmb.GetTableMessage(DataFlowElementId, this.WhereStatement, callback, this.TimeStamp));
}
catch (SdmxException) { throw; }
catch (Exception ex)
{
throw new SdmxException(this, FlyExceptionObject.FlyExceptionTypeEnum.DataMessageEngineGetResults, ex);
}
finally
{
DestroyObjects();
}
}
public static void RunSingleSegmentParser(int numberOfRequests, int concurrentConnections, byte[] requestPayload, WriteResponseDelegate writeResponse)
{
var factory = new PipeFactory();
var listener = new FakeListener(factory, concurrentConnections);
listener.OnConnection(async connection =>
{
while (true)
{
// Wait for data
var result = await connection.Input.ReadAsync();
ReadableBuffer input = result.Buffer;
try
{
if (input.IsEmpty && result.IsCompleted)
{
// No more data
break;
}
var requestBuffer = input.First;
if (requestBuffer.Length != 492)
{
continue;
}
// Parse the input http request
WritableBuffer output = WriteResponse(writeResponse, connection, requestBuffer);
await output.FlushAsync();
}
catch (Exception e)
{
var istr = new Utf8String(input.First.Span).ToString();
Debug.WriteLine(e.Message);
}
finally
{
// Consume the input
connection.Input.Advance(input.End, input.End);
}
}
});
var tasks = new Task[numberOfRequests];
for (int i = 0; i < numberOfRequests; i++)
{
tasks[i] = listener.ExecuteRequestAsync(requestPayload);
}
Task.WaitAll(tasks);
listener.Dispose();
factory.Dispose();
}
/// <summary>
/// Get structured Data Message from Database
/// </summary>
/// <param name="idDataset">Dataset Code</param>
/// <param name="whereStatement">Where condition</param>
/// <param name="BuilderCallback">delegate to call for write data response</param>
/// <param name="TimeStamp">LastUpdate parameter request only observation from this date onwards</param>
/// <returns>Object for Write response in streaming <see cref="IFlyWriterBody"/></returns>
public IFlyWriterBody GetTableMessage(string idDataset, IDataWhereStatment whereStatement, WriteResponseDelegate BuilderCallback, string TimeStamp)
{
try
{
string TimeWhere = "";
List <IParameterValue> parametri = new List <IParameterValue>()
{
new ParameterValue()
{
Item = "DataSetCode", Value = idDataset
},
new ParameterValue()
{
Item = "WhereStatement", Value = ConvertIDataQueryToWhereStatement(whereStatement, out TimeWhere)
},
new ParameterValue()
{
Item = "Time", Value = TimeWhere
},
new ParameterValue()
{
Item = "UserName", Value = FlyConfiguration.UserName
},
new ParameterValue()
{
Item = "Domain", Value = FlyConfiguration.Domain
},
};
if (!string.IsNullOrEmpty(TimeStamp))
{
parametri.Add(new ParameterValue()
{
Item = "TimeStamp", Value = TimeStamp, SqlType = SqlDbType.DateTime
});
}
FlyLog.WriteLog(this, FlyLog.LogTypeEnum.All, @"GetData parameter: {0}", string.Join("\n", parametri));
//EFFETTUO LA RICHIESTA AL DB
return(this.DbAccess.ExecuteGetData(parametri, new GetDBResponseDelegate(GetDBResponse), BuilderCallback));
}
catch (SdmxException) { throw; }
catch (Exception ex)
{
throw new SdmxException(this, FlyExceptionObject.FlyExceptionTypeEnum.GetTableMessage, ex);
}
}
/// <summary>
/// Get Database response and call delegate WriteBuilder
/// </summary>
/// <param name="rea">SqlDataReader response</param>
/// <param name="builder"> Delegate for callback of Write response</param>
/// <param name="writer"> Contains the object of transport used for transmitting data in streaming</param>
public void GetDBResponse(SqlDataReader rea, WriteResponseDelegate builder, IFlyWriter writer)
{
try
{
DataTable schemaTable = rea.GetSchemaTable();
IDataTableMessageObject DTMessage = new DataTableMessageObject();
List <string> columns = new List <string>();
foreach (DataRow item in schemaTable.Rows)
{
string itemColumnName = item["ColumnName"].ToString();
columns.Add(itemColumnName);
SpacialColumsNamesEnum tipoSpeciale;
IConceptObjectImpl conc = Concepts.Find(c =>
(c.Id.Trim().ToUpper() == itemColumnName.Trim().ToUpper()) ||
(c.Id.Trim().ToUpper() == itemColumnName.Trim().ToUpper().Substring(1)) ||
CheckRenamedFrequency(c, itemColumnName) ||
CheckRenamedFrequency(c, itemColumnName.Substring(1)));
if (conc != null)
{
DTMessage.Colums.Add(itemColumnName, conc);
}
else if (Enum.TryParse <SpacialColumsNamesEnum>(itemColumnName.Trim().ToUpper(), true, out tipoSpeciale))
{
switch (tipoSpeciale)
{
case SpacialColumsNamesEnum._TIME_:
case SpacialColumsNamesEnum._TIME:
DTMessage.Colums.Add(itemColumnName, Concepts.Find(c => c.ConceptType == ConceptTypeEnum.Dimension && ((IDimensionConcept)c).DimensionType == DimensionTypeEnum.Time));
break;
case SpacialColumsNamesEnum.VALUE:
case SpacialColumsNamesEnum._VALUE_:
if (Concepts.Exists(c => c.ConceptType == ConceptTypeEnum.Attribute && ((IAttributeConcept)c).IsValueAttribute))
{
DTMessage.Colums.Add(itemColumnName, Concepts.Find(c => c.ConceptType == ConceptTypeEnum.Attribute && ((IAttributeConcept)c).IsValueAttribute));
}
break;
case SpacialColumsNamesEnum.FLAGS:
if (Concepts.Exists(c => c.ConceptType == ConceptTypeEnum.Attribute && ((IAttributeConcept)c).IsFlagAttribute))
{
DTMessage.Colums.Add(itemColumnName, Concepts.Find(c => c.ConceptType == ConceptTypeEnum.Attribute && ((IAttributeConcept)c).IsFlagAttribute));
}
break;
}
}
}
//La colonna Frequency è obbligatoria (Se non c'è l'aggiungo)
if (string.IsNullOrEmpty(DTMessage.FrequencyCol))
{
var _freqconcept = Concepts.Find(c => c.ConceptType == ConceptTypeEnum.Dimension && ((IDimensionConcept)c).DimensionType == DimensionTypeEnum.Frequency && ((IDimensionConcept)c).IsFakeFrequency);
if (_freqconcept != null)
{
DTMessage.Colums.Add(_freqconcept.ConceptObjectCode, _freqconcept);
}
}
//Inseriamo anche la colonna TimeFormat a meno che non ci sia già nel db
if (string.IsNullOrEmpty(DTMessage.TimeFormatCol))
{
IConceptObjectImpl _timeFormatCol = Concepts.Find(co => co.ConceptType == ConceptTypeEnum.Attribute && co.Id == FlyConfiguration.Time_Format_Id);
if (_timeFormatCol != null)
{
DTMessage.Colums.Add(_timeFormatCol.ConceptObjectCode, _timeFormatCol);
}
}
DTMessage.DBDataReader = rea;
DTMessage.isFakeTimeFormat = !columns.Contains(DTMessage.TimeFormatCol);
builder(DTMessage, writer);
}
catch (SdmxException) { throw; }
catch (Exception ex)
{
throw new SdmxException(this, FlyExceptionObject.FlyExceptionTypeEnum.GetTableMessage, ex);
}
}
/// <summary>
/// Execute a store procedure for get a Data for DataMessage
/// </summary>
/// <param name="parameter">Parameters to be passed to the store procedure</param>
/// <param name="parse">Delegate to call for parse result</param>
/// <param name="builder">Delegate to pass at GetDBResponseDelegate for write result</param>
/// <returns>Object for Write response in streaming <see cref="IFlyWriterBody"/></returns>
public IFlyWriterBody ExecuteGetData(List <IParameterValue> parameter, GetDBResponseDelegate parse, WriteResponseDelegate builder)
{
try
{
_conn = new SqlConnection();
_conn.ConnectionString = this.ConnectionString;
_conn.Open();
SqlCommand cmd = new SqlCommand(GetStoreRef(DBOperationEnum.GetData), _conn);
cmd.CommandType = CommandType.StoredProcedure;
if (parameter != null)
{
parameter.ForEach(p => cmd.Parameters.Add(((ParameterValue)p).CreateParameter()));
}
//if (true)//FAKE
//{
// cmd = new SqlCommand("SELECT TOP 1000000 * FROM [Datawarehouse].[dbo].[Dataset_6_ViewAllData]", _conn);
// cmd.CommandType = CommandType.Text;
// cmd.Parameters.Clear();
//}
cmd.CommandTimeout = int.MaxValue;
SqlDataReader rea = cmd.ExecuteReader();
StringBuilder Par = new StringBuilder();
foreach (var item in parameter)
{
Par.AppendLine(String.Format("{0} \t\t-> {1}", item.Item, item.Value));
}
FlyLog.WriteLog(this, FlyLog.LogTypeEnum.All, @"Execution Store procedure {0} for data request Successfully. Reading results {1}", cmd.CommandText, Par);
return(new FlyDataWriterBody()
{
Rea = rea,
Conn = _conn,
Builder = builder,
Parser = parse
});
}
catch (SdmxException) { throw; }
catch (Exception e)
{
throw new SdmxException(this, FlyExceptionObject.FlyExceptionTypeEnum.DBErrorResponse, e);
}
}
