private void ExecuteAndCatchErrors(ODataRequest request, ODataResponse response, Action action)
{
try
{
action();
}
catch (Exception ex)
{
request.WriteToLog(this.Logger, LogLevel.Verbose);
response.WriteToLog(this.Logger, LogLevel.Verbose);
#if !SILVERLIGHT
if (this.Synchronizer != null)
{
EntitySet entitySet;
if (request.Uri.TryGetExpectedEntitySet(out entitySet))
{
try
{
SyncHelpers.ExecuteActionAndWait(c => this.Synchronizer.SynchronizeEntireEntitySet(c, entitySet.Name));
}
catch (Exception syncException)
{
this.Logger.WriteLine(LogLevel.Error, "Failed to synchronize set '{0}'", entitySet.Name);
this.Logger.WriteLine(LogLevel.Error, syncException.ToString());
}
}
}
#endif
throw new AssertionFailedException("Failed to deserialize response body", ex);
}
}
private void VerifyQueryResult(ODataRequest request, ODataResponse response, FunctionSegment functionSegment, IVerifyServiceActionQueryResult verifyServiceQueryResult)
{
EntitySet expectedBindingEntitySet = null;
var actionLessUri = ConstructODataUriWithoutActionInformation(this.entityModelSchema.GetDefaultEntityContainer().EntitySets, request.Uri);
bool entitySetFound = actionLessUri.TryGetExpectedEntitySet(out expectedBindingEntitySet);
ExceptionUtilities.Assert(entitySetFound, "EntitySet not found for Uri {0}", actionLessUri.ToString());
// SDP never applies for actions
var preActionQueryValueResult = this.ODataUriEvaluator.Evaluate(actionLessUri, true, false);
IDictionary <string, QueryValue> queryValueParametersLookup = new Dictionary <string, QueryValue>();
if (request.Body != null)
{
queryValueParametersLookup = this.CreateQueryValueParameters(request, functionSegment, queryValueParametersLookup);
}
var expected = verifyServiceQueryResult.GetExpectedQueryValue(preActionQueryValueResult, queryValueParametersLookup.Values.ToArray());
HttpStatusCode expectedStatusCode = CalculateExpectedStatusCode(functionSegment);
string expectedETag = null;
SyncHelpers.ExecuteActionAndWait(c => this.Synchronizer.SynchronizeEntireEntitySet(c, expectedBindingEntitySet.Name));
expectedETag = this.VerifyExpected(request, response, expected, expectedStatusCode, expectedETag);
ETagHeaderVerifier etagHeaderVerifier = new ETagHeaderVerifier();
etagHeaderVerifier.Verify(expectedETag, request, response);
}
/// <summary>
/// Gets the pre and post update representations of the entity updated by the given request
/// </summary>
/// <param name="request">The request</param>
/// <param name="beforeUpdate">The entity before the update</param>
/// <param name="afterUpdate">The entity after the update</param>
public void GetUpdatedEntity(ODataRequest request, out QueryStructuralValue beforeUpdate, out QueryStructuralValue afterUpdate)
{
ExceptionUtilities.CheckArgumentNotNull(request, "request");
ExceptionUtilities.Assert(this.requestsBegun.Contains(request), "Cannot use GetUpdatedEntity before calling Begin");
ExceptionUtilities.Assert(request.GetEffectiveVerb().IsUpdateVerb(), "Cannot use GetUpdatedEntity on non update requests");
KeyValuePair <QueryStructuralValue, QueryStructuralValue> beforeAndAfter;
if (!this.updatedEntityCache.TryGetValue(request, out beforeAndAfter))
{
var entityUri = request.Uri.ScopeToEntity();
var entity = (QueryStructuralValue)this.Evaluator.Evaluate(entityUri, false, false);
beforeUpdate = this.QueryValueCopier.PerformDeepCopy(entity);
SyncHelpers.ExecuteActionAndWait(c => this.Synchronizer.SynchronizeEntity(c, entity));
afterUpdate = entity;
beforeAndAfter = new KeyValuePair <QueryStructuralValue, QueryStructuralValue>(beforeUpdate, afterUpdate);
this.updatedEntityCache[request] = beforeAndAfter;
}
else
{
beforeUpdate = beforeAndAfter.Key;
afterUpdate = beforeAndAfter.Value;
}
}
public MyFracturedPiece()
: base()
{
//EntityId = MyEntityIdentifier.AllocateId();
//TODO: Synchronize through manager to avoid performance hits
SyncFlag = true;
base.PositionComp = new MyFracturePiecePositionComponent();
base.Render = new MyRenderComponentFracturedPiece();
base.Render.NeedsDraw = true;
base.Render.PersistentFlags = MyPersistentEntityFlags2.Enabled;
AddDebugRenderComponent(new MyFracturedPieceDebugDraw(this));
UseDamageSystem = false;
NeedsUpdate = MyEntityUpdateEnum.EACH_10TH_FRAME | MyEntityUpdateEnum.EACH_100TH_FRAME;
#if !XB1 // !XB1_SYNC_NOREFLECTION
SyncType = SyncHelpers.Compose(this);
#else // XB1
SyncType = new SyncType(new List <SyncBase>());
m_fallSoundShouldPlay = SyncType.CreateAndAddProp <bool>();
m_fallSoundString = SyncType.CreateAndAddProp <string>();
#endif // XB1
m_fallSoundShouldPlay.Value = false;
m_fallSoundString.Value = "";
m_fallSoundString.ValueChanged += (x) => SetFallSound();
}
public MySyncedBlock()
{
#if !XB1 // !XB1_SYNC_NOREFLECTION
SyncType = SyncHelpers.Compose(this);
#else // XB1
SyncType = new SyncType(new List <SyncBase>());
#endif // XB1
}
public MyFloatingObject()
{
this.WasRemovedFromWorld = false;
this.m_soundEmitter = new MyEntity3DSoundEmitter(this, false, 1f);
this.m_lastTimePlayedSound = MySandboxGame.TotalGamePlayTimeInMilliseconds;
base.Render = new MyRenderComponentFloatingObject();
this.SyncType = SyncHelpers.Compose(this, 0);
}
public static void ExecuteUriAndCompareSync <TResult>(this IClientQueryResultComparer linqToAstoriaResultComparer, IQueryable <TResult> query, string uriString, QueryValue expectedValue, DataServiceContext dataContext, ExpectedClientErrorBaseline clientExpectedError)
{
#if !SILVERLIGHT
SyncHelpers.ExecuteActionAndWait(c => linqToAstoriaResultComparer.ExecuteUriAndCompare <TResult>(c, false, query, uriString, expectedValue, dataContext, clientExpectedError));
#else
throw new TaupoInvalidOperationException("Cannot execute in Silverlight");
#endif
}
/// <summary>
/// Executes SaveChanges on the specified context and with specified options and verifies the results.
/// </summary>
/// <param name="verifier">The verifier to use for verification.</param>
/// <param name="contextData">The data for the context.</param>
/// <param name="context">The context to verify SaveChanges on.</param>
/// <param name="options">The options for saving changes.</param>
/// <returns>The response from SaveChanges</returns>
public static DSClient.DataServiceResponse VerifySaveChanges(this ISaveChangesVerifier verifier, DataServiceContextData contextData, DSClient.DataServiceContext context, SaveChangesOptions?options)
{
ExceptionUtilities.CheckArgumentNotNull(verifier, "verifier");
ExceptionUtilities.CheckArgumentNotNull(contextData, "contextData");
ExceptionUtilities.CheckArgumentNotNull(context, "context");
DSClient.DataServiceResponse response = null;
SyncHelpers.ExecuteActionAndWait(c1 => verifier.VerifySaveChanges(c1, contextData, context, options, (c2, r) => { response = r; c2.Continue(); }));
return(response);
}
public MyTerminalBlock()
{
CustomName = new StringBuilder();
DetailedInfo = new StringBuilder();
CustomInfo = new StringBuilder();
CustomNameWithFaction = new StringBuilder();
SyncType = SyncHelpers.Compose(this);
SyncType.PropertyChanged += sync => RaisePropertiesChanged();
}
public void Append(object obj)
{
var num = m_properties.Count;
SyncHelpers.Compose(obj, m_properties.Count, m_properties);
for (int i = num; i < m_properties.Count; i++)
{
m_properties[i].ValueChanged += m_registeredHandlers;
}
}
public MyFloatingObject()
{
WasRemovedFromWorld = false;
m_soundEmitter = new MyEntity3DSoundEmitter(this);
m_lastTimePlayedSound = MySandboxGame.TotalGamePlayTimeInMilliseconds;
Render = new Components.MyRenderComponentFloatingObject();
SyncType = SyncHelpers.Compose(this);
Amount.ValueChanged += (x) => { Item.Amount = Amount.Value; UpdateInternalState(); };
}
public MyAutomaticRifleGun()
{
NeedsUpdate = MyEntityUpdateEnum.EACH_FRAME;
Render.NeedsDraw = true;
m_gunBase = new MyGunBase();
m_soundEmitter = new MyEntity3DSoundEmitter(this);
(PositionComp as MyPositionComponent).WorldPositionChanged = WorldPositionChanged;
this.Render = new MyRenderComponentAutomaticRifle();
SyncType = SyncHelpers.Compose(this);
SyncType.Append(m_gunBase);
}
public void Append(object obj)
{
#if !UNSHAPER_TMP
//++m_TotalCount;
//System.Diagnostics.Debug.Print(m_TotalCount.ToString());
var num = m_properties.Count;
SyncHelpers.Compose(obj, m_properties.Count, m_properties);
for (int i = num; i < m_properties.Count; i++)
{
m_properties[i].ValueChanged += m_registeredHandlers;
}
#endif
}
/// <summary>
/// Executes SaveChanges on the specified context and with specified options and verifies the results.
/// </summary>
/// <param name="verifier">The verifier to use for verification.</param>
/// <param name="contextData">The data for the context.</param>
/// <param name="context">The context to verify SaveChanges on.</param>
/// <param name="options">The options for saving changes.</param>
/// <returns>The response from SaveChanges</returns>
public static DSClient.DataServiceResponse VerifySaveChanges(this ISaveChangesVerifier verifier, DataServiceContextData contextData, DSClient.DataServiceContext context, SaveChangesOptions? options)
{
#if SILVERLIGHT
throw new TaupoNotSupportedException("Not supported in Silverlight");
#else
ExceptionUtilities.CheckArgumentNotNull(verifier, "verifier");
ExceptionUtilities.CheckArgumentNotNull(contextData, "contextData");
ExceptionUtilities.CheckArgumentNotNull(context, "context");
DSClient.DataServiceResponse response = null;
SyncHelpers.ExecuteActionAndWait(c1 => verifier.VerifySaveChanges(c1, contextData, context, options, (c2, r) => { response = r; c2.Continue(); }));
return response;
#endif
}
public MyFloatingObject()
{
WasRemovedFromWorld = false;
m_soundEmitter = new MyEntity3DSoundEmitter(this);
m_lastTimePlayedSound = MySandboxGame.TotalGamePlayTimeInMilliseconds;
Render = new Components.MyRenderComponentFloatingObject();
#if !XB1 // !XB1_SYNC_NOREFLECTION
SyncType = SyncHelpers.Compose(this);
#else // XB1
SyncType = new SyncType(new List <SyncBase>());
Amount = SyncType.CreateAndAddProp <MyFixedPoint>();
#endif // XB1
Amount.ValueChanged += (x) => { Item.Amount = Amount.Value; UpdateInternalState(); };
}
private QueryValue SynchronizeAndEvaluate(ODataUri entityUri, QueryStructuralValue beforeSync, bool synchronizeEntireSet)
{
var entityType = beforeSync.Type as QueryEntityType;
ExceptionUtilities.CheckObjectNotNull(entityType, "Structural value was not an entity type");
// if an entity was deleted, synchronize the entire set. Otherwise just synchronize the entity
if (synchronizeEntireSet)
{
SyncHelpers.ExecuteActionAndWait(c => this.Synchronizer.SynchronizeEntireEntitySet(c, entityType.EntitySet.Name));
}
else
{
SyncHelpers.ExecuteActionAndWait(c => this.Synchronizer.SynchronizeEntity(c, beforeSync));
}
return(this.Evaluator.Evaluate(entityUri, false, false));
}
public static void SaveException(String message, Exception exception, String extraStackTrace = null)
{
if (!Initialized)
{
return;
}
try
{
var log = GetLog(message, exception, extraStackTrace);
var filename = String.Format("crash{0}.log", DateTime.UtcNow.ToString("s").Replace(":", "-"));
SyncHelpers.WriteFile(CrashFolderPath, filename, log, Encoding.UTF8);
}
catch
{
// Swallow exceptions during saving a previous exception
}
}
public MyAutomaticRifleGun()
{
NeedsUpdate = MyEntityUpdateEnum.EACH_FRAME;
Render.NeedsDraw = true;
#if XB1 // XB1_SYNC_NOREFLECTION
SyncType = new SyncType(new List <SyncBase>());
m_gunBase = new MyGunBase(SyncType);
#else // !XB1
m_gunBase = new MyGunBase();
#endif // !XB1
m_soundEmitter = new MyEntity3DSoundEmitter(this);
(PositionComp as MyPositionComponent).WorldPositionChanged = WorldPositionChanged;
this.Render = new MyRenderComponentAutomaticRifle();
#if !XB1 // !XB1_SYNC_NOREFLECTION
SyncType = SyncHelpers.Compose(this);
SyncType.Append(m_gunBase);
#endif // !XB1
}
/// <summary>
/// Gets the entity inserted by the given request.
/// </summary>
/// <param name="request">The request</param>
/// <param name="response">The response</param>
/// <returns>The inserted entity</returns>
public QueryStructuralValue GetInsertedEntity(ODataRequest request, ODataResponse response)
{
ExceptionUtilities.CheckArgumentNotNull(request, "request");
ExceptionUtilities.CheckArgumentNotNull(response, "response");
ExceptionUtilities.Assert(this.requestsBegun.Contains(request), "Cannot use GetInsertedEntity before calling Begin");
ExceptionUtilities.Assert(request.GetEffectiveVerb() == HttpVerb.Post, "Cannot use GetInsertedEntity on non POST requests");
QueryStructuralValue insertedEntity;
if (!this.insertedEntityCache.TryGetValue(request, out insertedEntity))
{
EntitySet entitySet;
ExceptionUtilities.Assert(request.Uri.TryGetExpectedEntitySet(out entitySet), "Could not infer entity set from URI");
var entitySetUri = new ODataUri(new EntitySetSegment(entitySet));
var beforeSync = this.Evaluator.Evaluate(entitySetUri, false, false) as QueryCollectionValue;
ExceptionUtilities.CheckObjectNotNull(beforeSync, "Could not evaluate entity set '{0}' before syncing", entitySet.Name);
// create a shallow copy
beforeSync = beforeSync.Type.CreateCollectionWithValues(beforeSync.Elements);
SyncHelpers.ExecuteActionAndWait(c => this.Synchronizer.SynchronizeEntireEntitySet(c, entitySet.Name));
var afterSync = this.Evaluator.Evaluate(entitySetUri, false, false) as QueryCollectionValue;
ExceptionUtilities.CheckObjectNotNull(afterSync, "Could not evaluate entity set '{0}' after syncing", entitySet.Name);
// TODO: handle deep insert (using location header or response payload)
var newElements = afterSync.Elements.Except(beforeSync.Elements).OfType <QueryStructuralValue>().ToList();
this.insertedEntityCache[request] = insertedEntity = newElements.Single();
// update the parent entity, if there is one
var segments = request.Uri.Segments;
var lastNavigationSegment = segments.OfType <NavigationSegment>().LastOrDefault();
if (lastNavigationSegment != null)
{
var segmentsBeforeNavigation = segments.TakeWhile(t => t != lastNavigationSegment);
var parentEntity = (QueryStructuralValue)this.Evaluator.Evaluate(new ODataUri(segmentsBeforeNavigation), false, false);
SyncHelpers.ExecuteActionAndWait(c => this.Synchronizer.SynchronizeEntity(c, parentEntity));
}
}
return(insertedEntity);
}
public MyFracturedPiece()
: base()
{
//EntityId = MyEntityIdentifier.AllocateId();
//TODO: Synchronize through manager to avoid performance hits
SyncFlag = true;
base.PositionComp = new MyFracturePiecePositionComponent();
base.Render = new MyRenderComponentFracturedPiece();
base.Render.NeedsDraw = true;
base.Render.PersistentFlags = MyPersistentEntityFlags2.Enabled;
AddDebugRenderComponent(new MyFracturedPieceDebugDraw(this));
UseDamageSystem = false;
NeedsUpdate = MyEntityUpdateEnum.EACH_10TH_FRAME;
SyncType = SyncHelpers.Compose(this);
m_fallSoundShouldPlay.Value = false;
m_fallSoundString.Value = "";
m_fallSoundString.ValueChanged += (x) => SetFallSound();
}
public MySyncedBlock()
{
SyncType = SyncHelpers.Compose(this);
}
public static void ExecuteUriAndCompareSync <TResult>(this IClientQueryResultComparer linqToAstoriaResultComparer, IQueryable <TResult> query, string uriString, QueryValue expectedValue, DataServiceContext dataContext, ExpectedClientErrorBaseline clientExpectedError)
{
SyncHelpers.ExecuteActionAndWait(c => linqToAstoriaResultComparer.ExecuteUriAndCompare <TResult>(c, false, query, uriString, expectedValue, dataContext, clientExpectedError));
}
public MySyncedBlock()
{
this.SyncType = SyncHelpers.Compose(this, 0);
}
