public IEnumerable RunQuery(Type entityType, IInternalSession session, String query,
IEnumerable<Parameter> parameters)
{
session.Open();
DbCommand cmd = session.CreateCommand();
cmd.CommandText = query;
cmd.SetParameters(
parameters.Select(p => new KeyValuePair<Key, Object>(new Key(p.Field, p.ParamName), p.Value)));
IDataReader reader = cmd.ExecuteReader();
try
{
return reader.AsParallel().Transform(t =>
{
object newEntity = _Factory.Make(entityType, session, null);
_Loader.Load(newEntity, session, t.Reader);
return newEntity;
});
}
finally
{
reader.Close();
session.Close();
}
}
public void Execute(string statement, IInternalSession session)
{
DbCommand command = session.CreateCommand();
command.CommandText = statement;
command.ExecuteNonQuery();
}
public SerializationSession(Func<IEnumerable<IPersistenceEvent>> getCurrentPersistenceEvents, IInternalSession internalSession, bool untracked)
{
GetCurrentPersistenceEvents = getCurrentPersistenceEvents;
InternalSession = internalSession;
ActivelyDeserialising = new Dictionary<InternalId, object>();
this.untracked = untracked;
}
public Object Make(Type type, IInternalSession session, IEntityTranslator translator)
{
return type.Namespace.Equals("Castle.Proxies")
? Make(type.BaseType, session, null)
: proxyGenerator.CreateClassProxy(type,
new Interceptor(
session));
}
protected override void Given()
{
mockInternalSession = MockRepository.GenerateMock<IInternalSession>();
var mockRegistry = MockRepository.GenerateStub<IRegistry>();
var mockBackingStore = MockRepository.GenerateStub<IBackingStore>();
var mockQueryFactory = MockRepository.GenerateStub<IQueryFactory>();
subject = new StashedSet<DummyPersistentObject>(mockInternalSession, mockRegistry, mockBackingStore, mockQueryFactory, new StashedSet<DummyPersistentObject>[0]);
mockRegisteredGraph = MockRepository.GenerateStub<IRegisteredGraph<DummyPersistentObject>>();
mockRegistry.Stub(_ => _.GetRegistrationFor(Arg<Type>.Is.Anything)).Return(mockRegisteredGraph);
expected = new DummyPersistentObject();
}
public ITransaction BeginTransaction(IInternalSession session, DbConnection connection)
{
_Session = session;
if (_Transaction == null || Ended)
{
Ended = false;
_Transaction = connection.BeginTransaction();
}
else
{
BeginNestedTransaction();
}
return this;
}
public object Make(Type type, IInternalSession session, IEntityTranslator translator)
{
if (type.GetInterfaces().Contains(typeof(IProxyTargetAccessor)))
{
return Make(type.BaseType, session, translator);
}
return proxyGenerator.CreateClassProxy(type,
new ProxyGenerationOptions {
Selector = new InterceptorSelector(
new NonCollectionInterceptor(session),
new CollectionPropertyInterceptor(session, translator)
)
});
}
protected override void Given()
{
mockInternalSession = MockRepository.GenerateMock<IInternalSession>();
var mockRegistry = MockRepository.GenerateStub<IRegistry>();
var mockBackingStore = MockRepository.GenerateStub<IBackingStore>();
var mockQueryFactory = MockRepository.GenerateStub<IQueryFactory>();
subject = new StashedSet<DummyPersistentObject>(
mockInternalSession,
mockRegistry,
mockBackingStore,
mockQueryFactory,
new[] {new StashedSet<DummyPersistentObject>(mockInternalSession, mockRegistry, mockBackingStore, mockQueryFactory)});
mockRegisteredGraph = MockRepository.GenerateStub<IRegisteredGraph<DummyPersistentObject>>();
mockRegistry.Stub(_ => _.GetRegistrationFor(Arg<Type>.Is.Anything)).Return(mockRegisteredGraph);
mockStoredGraph = MockRepository.GenerateStub<IStoredGraph>();
mockBackingStore.Stub(_ => _.Get((IQuery)null)).IgnoreArguments().Return(new[] {mockStoredGraph});
mockTrack = MockRepository.GenerateStub<ITrack>();
mockTrack.Stub(_ => _.UntypedGraph).Return(new DummyPersistentObject());
}
public OfflineLastSessionResult(bool success, IInternalSession session)
{
Success = success;
InternalSession = session;
}
public IRequestHandler Create(IInternalSession session, ISerializer serializer)
{
return(CreateMockHandler());
}
public IGraphRequestHandler CreateGraphRequestHandler(IInternalSession session, IGraphTypeSerializerFactory resolver)
{
return(new GraphRequestHandler(session, resolver));
}
protected override IRequestHandler NewRequestHandler(IInternalSession session, Serializer serializer, IRequest request, IStatement statement)
{
return(Mock.Of <IRequestHandler>());
}
public IRequestHandler Create(IInternalSession session, ISerializer serializer, IStatement statement, IRequestOptions options)
{
return(CreateMockHandler(statement));
}
public Dictionary <string, object> GetInformation(IInternalCluster cluster, IInternalSession session)
{
return(null);
}
protected override IRequestExecution NewExecution(IInternalSession session, IRequest request)
{
return(Mock.Of <IRequestExecution>());
}
public NonCollectionInterceptor(IInternalSession session)
: base(false)
{
_Session = session;
}
public ProxyRequestHandler(IInternalSession session, Serializer serializer) : base(session, serializer)
{
}
private static InsightsClient GetInsightsClient(IInternalCluster cluster, IInternalSession session)
{
var hostnameInfoMock = Mock.Of <IInsightsInfoProvider <string> >();
var driverInfoMock = Mock.Of <IInsightsInfoProvider <DriverInfo> >();
var timestampGeneratorMock = Mock.Of <IInsightsMetadataTimestampGenerator>();
var platformInfoMock = Mock.Of <IInsightsInfoProvider <InsightsPlatformInfo> >();
Mock.Get(hostnameInfoMock).Setup(m => m.GetInformation(cluster, session)).Returns("awesome_hostname");
Mock.Get(driverInfoMock).Setup(m => m.GetInformation(cluster, session)).Returns(new DriverInfo
{
DriverVersion = "1.1.2",
DriverName = "Driver Name"
});
Mock.Get(timestampGeneratorMock).Setup(m => m.GenerateTimestamp()).Returns(124219041);
Mock.Get(platformInfoMock).Setup(m => m.GetInformation(cluster, session)).Returns(new InsightsPlatformInfo
{
CentralProcessingUnits = new CentralProcessingUnitsInfo
{
Length = 2,
Model = "Awesome CPU"
},
Runtime = new RuntimeInfo
{
Dependencies = new Dictionary <string, AssemblyInfo>
{
{ "Assembly1", new AssemblyInfo {
Version = "1.2.0", Name = "Assembly1", FullName = "Assembly1FullName"
} }
},
RuntimeFramework = "runtime-framework",
TargetFramework = "target-framework"
},
OperatingSystem = new OperatingSystemInfo
{
Version = "os version",
Name = "os name",
Arch = "os arch"
}
});
var target = new InsightsClient(
cluster,
session,
new InsightsStartupMessageFactory(
new InsightsMetadataFactory(timestampGeneratorMock),
new InsightsInfoProvidersCollection(
platformInfoMock,
new ExecutionProfileInfoProvider(
new LoadBalancingPolicyInfoProvider(new ReconnectionPolicyInfoProvider()),
new SpeculativeExecutionPolicyInfoProvider(),
new RetryPolicyInfoProvider()),
new PoolSizeByHostDistanceInfoProvider(),
new AuthProviderInfoProvider(),
new DataCentersInfoProvider(),
new OtherOptionsInfoProvider(),
new ConfigAntiPatternsInfoProvider(),
new ReconnectionPolicyInfoProvider(),
driverInfoMock,
hostnameInfoMock)),
new InsightsStatusMessageFactory(
new InsightsMetadataFactory(timestampGeneratorMock),
new NodeStatusInfoProvider()));
return(target);
}
protected virtual IRequestHandler NewRequestHandler(
IInternalSession session, Serializer serializer, IRequest request, IStatement statement)
{
return(new RequestHandler(session, _parent.Serializer, request, statement));
}
public IRequestHandler Create(IInternalSession session, ISerializer serializer)
{
return(new RequestHandler(session, serializer));
}
public IRequestHandler Create(IInternalSession session, ISerializer serializer, IRequest request, IStatement statement, IRequestOptions options)
{
return(new RequestHandler(session, serializer, request, statement, options));
}
/// <inheritdoc />
public void InitializeMetrics(IInternalSession session)
{
_sessionMetrics.InitializeMetrics(session);
}
protected DbCommandFactory(IInternalSession internalSession)
{
_internalSession = internalSession;
}
/// <summary>
/// Creates a new instance with no request, suitable for getting a connection.
/// </summary>
public RequestHandler(IInternalSession session, Serializer serializer)
: this(session, serializer, null, null, session.Cluster.Configuration.DefaultRequestOptions)
{
}
private void HandleRefreshSuccess(Action <IRestoreLastSessionResult> callback, GuestControllerResult <RefreshResponse> result, SessionDocument lastSessionDoc)
{
try
{
GuestApiErrorCollection error2 = result.Response.error;
RefreshData data = result.Response.data;
IRestoreLastSessionResult error = GuestControllerErrorParser.GetRestoreLastSessionResult(error2);
if (data == null && error != null)
{
if (error is IRestoreLastSessionFailedInvalidOrExpiredTokenResult && lastSessionDoc.AccountStatus == "AWAIT_PARENT_CONSENT")
{
callback(new RestoreLastSessionFailedParentalConsentResult());
}
else
{
callback(error);
}
}
else if (data == null)
{
if (error2 != null)
{
logger.Critical("Received unhandled error exception:\n" + JsonParser.ToJson(error2) + "\nResponse headers:\n" + string.Join("\n", (from h in result.ResponseHeaders
select h.Key + ": " + h.Value).ToArray()));
}
callback(new RestoreLastSessionResult(success: false, null));
}
else if (!ValidateRefreshData(data))
{
logger.Critical("Error parsing the refresh data: " + JsonParser.ToJson(data));
callback(new RestoreLastSessionResult(success: false, null));
}
else
{
Token token = data.token;
lastSessionDoc.GuestControllerAccessToken = token.access_token;
lastSessionDoc.GuestControllerEtag = data.etag;
database.UpdateGuestControllerToken(token, data.etag);
try
{
IInternalSession session = sessionFactory.Create(lastSessionDoc.Swid);
session.Resume(delegate(IResumeSessionResult r)
{
HandleOfflineSessionResumed(r, session, error, callback);
});
}
catch (Exception arg)
{
logger.Critical("Error creating session: " + arg);
callback(new RestoreLastSessionResult(success: false, null));
}
}
}
catch (CorruptionException arg2)
{
logger.Fatal("Corruption detected during session restoration: " + arg2);
callback(new RestoreLastSessionCorruptionDetectedResult());
}
catch (Exception arg)
{
logger.Critical("Unhandled exception: " + arg);
callback(new RestoreLastSessionResult(success: false, null));
}
}
public PrepareHandlerMockResult(PrepareHandler prepareHandler, IInternalSession session, FakeConnectionFactory factory)
{
PrepareHandler = prepareHandler;
Session = session;
ConnectionFactory = factory;
}
public IInsightsClient Create(IInternalCluster cluster, IInternalSession session)
{
return(new InsightsClient(cluster, session, _startupMessageFactory, _statusMessageFactory));
}
internal static ISessionState GetState(this IInternalSession instance)
{
return(SessionState.From(instance));
}
/// <summary>
/// Creates a new instance using the statement to build the request.
/// Statement can not be null.
/// </summary>
public RequestHandler(IInternalSession session, Serializer serializer, IStatement statement, IRequestOptions requestOptions)
: this(session, serializer, RequestHandler.GetRequest(statement, serializer, requestOptions), statement, requestOptions)
{
}
public ProxyRequestExecution(IRequestHandler parent, IInternalSession session, IRequest request) : base(parent, session, request)
{
}
public DbCommandBypass(IInternalSession internalSession, String cmdMask, params Object[] args)
: base(internalSession)
{
_cmdMask = cmdMask;
_args = args;
}
public string GetInformation(IInternalCluster cluster, IInternalSession session)
{
return(Dns.GetHostName());
}
