public IHttpActionResult Postrq_operaciones(rq_operaciones rqOperaciones)
{
tracer.Debug(Request, this.ControllerContext.ControllerDescriptor.ControllerType.FullName, "URI: " + Request.RequestUri);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
int operaciones_guardadas = 0;
try
{
db.rq_operaciones.Add(rqOperaciones);
operaciones_guardadas = db.SaveChanges();
tracer.Debug(Request, this.ControllerContext.ControllerDescriptor.ControllerType.FullName, "Operaciones guardadas: " + operaciones_guardadas);
}
catch (System.Exception ex)
{
tracer.Error(Request, this.ControllerContext.ControllerDescriptor.ControllerType.FullName, "Operacion de BBDD fallida: " + ex.Message);
throw;
}
if (operaciones_guardadas == 0)
{
tracer.Warn(Request, this.ControllerContext.ControllerDescriptor.ControllerType.FullName, "Operacion SaveChanges sin exito: " + operaciones_guardadas);
return(BadRequest(ModelState));
}
else
{
return(CreatedAtRoute("DefaultApi", new { id = rqOperaciones.ID_Operacion }, rqOperaciones));
}
}
public void SingleEvent()
{
SetUp();
try
{
using (var bus = new IpcServiceBus(string.Format("tcp://localhost:{0}", _pubPort), string.Format("tcp://localhost:{0}", _subPort), VerboseLog, Logger))
using (var signal = new ManualResetEvent(false))
{
const long testEventCode = 1;
IPublisher publisher = null;
ISubscriber subscriber = bus.CreateSubscriber(testEventCode);
try
{
TestEvent testEventReceived = null;
int messageReceivedCount = 0;
subscriber.OnMessage += (o, e) =>
{
Logger.Debug("Test event received.");
messageReceivedCount++;
Assert.AreEqual(testEventCode, e.EventCode, "Event code received unexpected.");
testEventReceived = e.GetMessage <TestEvent>();
signal.Set();
};
publisher = bus.CreatePublisher();
var eventToSend = new TestEvent()
{
SendTimeTicks = DateTime.UtcNow.Ticks
};
Stopwatch watch = Stopwatch.StartNew();
publisher.Publish(testEventCode, eventToSend);
Assert.IsTrue(signal.WaitOne(300), "No event received.");
watch.Stop();
Logger.Debug("Delay between send/rec: {0:F02} ms. (ticks: {1}).", watch.ElapsedMilliseconds, watch.ElapsedTicks);
Assert.AreEqual(1, messageReceivedCount, "messageReceivedCount unexpected.");
Assert.AreEqual(eventToSend.SendTimeTicks, testEventReceived.SendTimeTicks, "testEventReceived.SendTimeTicks unexpected.");
}
finally
{
bus.Release(subscriber);
if (publisher != null)
{
bus.Release(publisher);
}
}
}
}
finally
{
TearDown();
}
}
public bool TrySync(Publisher pub)
{
Subscriber syncSub = new Subscriber(_subAddress, _context, SyncEventSingleFilter, _syncTimeout, _verboseLog, _verboseLog ? _traces : EmptyTraceWriter.Instance);
_traces.Debug("Try sync pub {0:x} with special subscriber {1:x}...", pub.InstanceId, syncSub.InstanceId);
try
{
return(TrySync(pub, syncSub, syncSub.InstanceId));
}
finally
{
_traces.Debug("Terminating syncsub {0:x}.", syncSub.InstanceId);
syncSub.Terminate();
}
}
/// <summary>
/// Logs to the TraceWriter, if available.
/// </summary>
protected void Log(System.Web.Http.Tracing.TraceLevel level, string methodName, string msg)
{
msg = "Method: " + methodName + ". " + msg;//prepend method name
ITraceWriter tracewriter = Configuration.Services.GetTraceWriter();
if (tracewriter != null)
{
switch (level)
{
case System.Web.Http.Tracing.TraceLevel.Error:
tracewriter.Error(Request, "", msg);
break;
case System.Web.Http.Tracing.TraceLevel.Warn:
tracewriter.Warn(Request, "", msg);
break;
case System.Web.Http.Tracing.TraceLevel.Info:
tracewriter.Info(Request, "", msg);
break;
default:
tracewriter.Debug(Request, "", msg);
break;
}
}
}
/// <summary>
/// <para>Constructs a publisher socket.</para>
/// </summary>
/// <param name="address">Address to which to connect (for example: tcp://localhost:9001).</param>
/// <param name="context">ZMQ Context.</param>
/// <param name="verboseLog">Enable tracing of each event published.</param>
/// <param name="traceWriter">Traces</param>
internal Publisher(string address, NetMQContext context, bool verboseLog, ITraceWriter traceWriter)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (string.IsNullOrEmpty(address))
{
throw new ArgumentNullException("address");
}
if (traceWriter == null)
{
throw new ArgumentNullException("traceWriter");
}
_traces = traceWriter;
_verboseLog = verboseLog;
_instanceHashCode = this.GetHashCode();
_socket = context.CreatePublisherSocket();
_socket.Options.SendHighWatermark = 100000;
try
{
_socket.Connect(address);
_traces.Debug("Publisher({0:x}) created ({1}).", _instanceHashCode, address);
}
catch (Exception ex)
{
_traces.Error(ex);
_socket.Dispose();
throw;
}
}
public void Dispose()
{
if (Interlocked.Increment(ref _disposeCount) != 1)
{
return;
}
try
{
_context.Dispose();
_traces.Debug("IpcEventProxy disposed.");
}
catch (NetMQException ex)
{
_traces.Error(ex);
}
}
public void Publish <T>(long eventCode, T message) where T : class
{
if (message == null)
{
throw new ArgumentNullException("message");
}
const int int64Length = 8;
var ms = new MemoryStream();
try
{
try
{
Serializer.Serialize <T>(ms, message);
}
catch (InvalidOperationException ex)
{
throw new SerializationException(ex, "Error when serializing event of type {0}. Check if that type is a valid Protobuf contract (annotated with ProtoContractAttribute).", typeof(T).FullName);
}
catch (Exception ex)
{
throw new SerializationException(ex, "Error when serializing event of type {0}.", typeof(T).FullName);
}
byte[] buffer = ms.ToArray();
_socket.Send(BitConverter.GetBytes(eventCode), int64Length, SendReceiveOptions.SendMore);
_socket.Send(buffer, buffer.Length, SendReceiveOptions.None);
if (_verboseLog)
{
_traces.Debug("Publisher({0:x}): event {1} sent.", _instanceHashCode, eventCode);
}
}
catch (TerminatingException)
{
// We ignore errors if ZMQ context is in termination phase.
}
finally
{
ms.Dispose();
}
}
/// <summary>
/// Submits the change through Entity Framework while logging any exceptions
/// and produce appropriate <see cref="HttpResponseMessage"/> instances.
/// </summary>
/// <returns>A <see cref="Task"/> representing the operation.</returns>
public static async Task <int> SubmitChangesAsync(DbContext context, HttpRequestMessage request, Func <DbUpdateConcurrencyException, object> getOriginalValue)
{
HttpConfiguration config = request.GetConfiguration();
ITraceWriter traceWriter = config.Services.GetTraceWriter();
try
{
int result = await context.SaveChangesAsync();
return(result);
}
catch (DbEntityValidationException ex)
{
string validationDescription = EntityUtils.GetValidationDescription(ex);
string validationError = EFResources.DomainManager_ValidationError.FormatForUser(validationDescription);
traceWriter.Debug(validationError, request, LogCategories.TableControllers);
HttpResponseMessage invalid = request.CreateErrorResponse(HttpStatusCode.BadRequest, validationError, ex);
throw new HttpResponseException(invalid);
}
catch (DbUpdateConcurrencyException ex)
{
string conflictError = EFResources.DomainManager_ChangeConflict.FormatForUser(ex.Message);
traceWriter.Info(conflictError, request, LogCategories.TableControllers);
var content = getOriginalValue != null?getOriginalValue(ex) : conflictError;
HttpStatusCode statusCode = GetConflictStatusCode(request);
HttpResponseMessage conflict = request.CreateResponse(statusCode, content);
throw new HttpResponseException(conflict);
}
catch (DbUpdateException ex)
{
HttpResponseMessage error;
Exception baseEx = ex.GetBaseException();
SqlException sqlException = baseEx as SqlException;
if (sqlException != null && sqlException.Number == SqlUniqueConstraintViolationError)
{
string message = CommonResources.DomainManager_Conflict.FormatForUser(sqlException.Message);
error = request.CreateErrorResponse(HttpStatusCode.Conflict, message);
traceWriter.Info(message, request, LogCategories.TableControllers);
}
else
{
string message = EFResources.DomainManager_InvalidOperation.FormatForUser(baseEx.Message);
error = request.CreateErrorResponse(HttpStatusCode.BadRequest, message);
traceWriter.Error(message, request, LogCategories.TableControllers);
}
throw new HttpResponseException(error);
}
}
private async Task <MovieResult> getMovie(string field, object value, string orderBy = null)
{
SDKClientTestContext context = new SDKClientTestContext();
var Movies = context.Movies;
ITraceWriter traceWriter = this.Configuration.Services.GetTraceWriter();
traceWriter.Debug("table: " + "Movies");
traceWriter.Debug("Field: " + field + ", value: " + value);
traceWriter.Debug("OrderBy: " + (orderBy == null ? "<null>" : orderBy));
IQueryable <Movie> t2 = Movies.Where(p => true);
t2 = Where(t2, field, value);
if (orderBy != null)
{
t2 = OrderBy(t2, orderBy);
}
var results = await t2.ToListAsync();
return(new MovieResult()
{
Movies = results.ToArray()
});
}
public string[] GetCars()
{
ITraceWriter traceWriter = Configuration.Services.GetTraceWriter();
traceWriter.Debug(Request, "Owin.Logging.Adapters.WebApi.Sample.Controllers.CarsController", "Special log message");
traceWriter.Info(Request, "Owin.Logging.Adapters.WebApi.Sample.Controllers.CarsController", "Special log message");
traceWriter.Warn(Request, "Owin.Logging.Adapters.WebApi.Sample.Controllers.CarsController", "Special log message");
traceWriter.Error(Request, "Owin.Logging.Adapters.WebApi.Sample.Controllers.CarsController", "Special log message");
traceWriter.Fatal(Request, "Owin.Logging.Adapters.WebApi.Sample.Controllers.CarsController", "Special log message");
return(new[]
{
"Car 1",
"Car 2",
"Car 3"
});
}
private void ListenSocket(object state)
{
var cancellationToken = (CancellationToken)state;
var socket = _context.CreateSubscriberSocket();
try
{
socket.Options.ReceiveTimeout = _recTimeout;
socket.Options.ReceiveHighWatermark = 100000;
socket.Connect(_address);
if (_topicsToSubscribe.Length != 0)
{
foreach (var filter in _topicsToSubscribe)
{
socket.Subscribe(filter);
}
}
else
{
socket.Subscribe(string.Empty);
}
_traces.Debug("Subscriber({0:x}) created ({1}).", _instanceHashCode, _address);
byte[] buffer;
while (_terminateCount == 0 && !cancellationToken.IsCancellationRequested)
{
buffer = _traces.CaptureMqExceptions <AgainException, byte[]>(socket.Receive);
if (buffer == null)
{
continue;
}
byte[] eventTopic = buffer.ToArray();
buffer = _traces.CaptureMqExceptions <AgainException, byte[]>(socket.Receive);
if (buffer == null)
{
continue;
}
if (Internals.SyncEvent.EventPrefix.SequenceEqual(eventTopic))
{
if (_synced)
{
continue;
}
using (var ms = new MemoryStream(buffer, 0, buffer.Length, false))
{
var data = Serializer.Deserialize <Internals.SyncEvent>(ms);
if (data.SubscriberInstanceId == _instanceHashCode)
{
if (_verboseLog)
{
_traces.Debug("Subscriber({0:x}): sync event received.", _instanceHashCode);
}
_synced = true;
}
}
}
else
{
long eventCode = BitConverter.ToInt64(eventTopic, 0);
if (_verboseLog)
{
_traces.Debug("Subscriber({0:x}): event {1} received.", _instanceHashCode, eventCode);
}
var eventHandler = OnMessage;
if (eventHandler != null)
{
try
{
eventHandler(this, new MessageEventArgs(eventCode, buffer));
}
catch (Exception ex)
{
_traces.Error(ex, "Subscriber({0:x}): Error on receiving event {0}.", _instanceHashCode, eventCode);
}
}
}
}
}
catch (TerminatingException)
{
// ZMQ context is in terminating phase...
}
catch (Exception ex)
{
_traces.Error(ex);
}
finally
{
if (_traces.CaptureMqExceptions(socket.Dispose))
{
_traces.Debug("Subscriber({0:x}) disposed.", _instanceHashCode);
}
}
}
public static void Debug(this ITraceWriter tracer, HttpRequestMessage request, ApiController controller, string messageFormat, params object[] messageArguments)
{
tracer.Debug(request, controller.ControllerContext.ControllerDescriptor.ControllerType.FullName, messageFormat, messageArguments);
}
public static void Debug(this ITraceWriter tracer, HttpRequestMessage request, ApiController controller, Exception exception)
{
tracer.Debug(request, controller.ControllerContext.ControllerDescriptor.ControllerType.FullName, exception);
}
