public IRemoteServerCursor OpenCursor(string expression, ref RemoteParamData paramsValue, out IRemoteServerExpressionPlan plan, out PlanDescriptor planDescriptor, out ProgramStatistics executeTime, ProcessCallInfo callInfo, RemoteProcessCleanupInfo cleanupInfo, out Guid[] bookmarks, int count, out RemoteFetchData fetchData)
{
try
{
var channel = GetServiceInterface();
IAsyncResult result = channel.BeginOpenCursorWithFetch(ProcessHandle, GetCleanupInfo(cleanupInfo), callInfo, expression, paramsValue, count, null, null);
result.AsyncWaitHandle.WaitOne();
DirectCursorWithFetchResult cursorResult = channel.EndOpenCursorWithFetch(result);
paramsValue.Data = cursorResult.ParamData;
planDescriptor = cursorResult.PlanDescriptor;
executeTime = cursorResult.ExecuteTime;
bookmarks = cursorResult.Bookmarks;
fetchData = cursorResult.FetchData;
plan = new ClientExpressionPlan(this, planDescriptor);
return(new ClientCursor((ClientExpressionPlan)plan, cursorResult.CursorDescriptor));
}
catch (FaultException <DataphorFault> fault)
{
throw DataphorFaultUtility.FaultToException(fault.Detail);
}
catch (CommunicationException ce)
{
ReportCommunicationError();
throw new ServerException(ServerException.Codes.CommunicationFailure, ErrorSeverity.Environment, ce);
}
}
public IRemoteServerPlan Prepare(RemoteParam[] paramsValue)
{
try
{
var channel = GetServiceInterface();
IAsyncResult result = channel.BeginPrepareBatch(BatchHandle, paramsValue, null, null);
result.AsyncWaitHandle.WaitOne();
PlanDescriptor planDescriptor = channel.EndPrepareBatch(result);
if (IsExpression())
{
return(new ClientExpressionPlan(_clientScript.ClientProcess, planDescriptor));
}
else
{
return(new ClientStatementPlan(_clientScript.ClientProcess, planDescriptor));
}
}
catch (FaultException <DataphorFault> fault)
{
throw DataphorFaultUtility.FaultToException(fault.Detail);
}
catch (CommunicationException ce)
{
ReportCommunicationError();
throw new ServerException(ServerException.Codes.CommunicationFailure, ErrorSeverity.Environment, ce);
}
}
protected override void Dispose(bool disposing)
{
try
{
try
{
var channel = GetServiceInterface();
IAsyncResult result = channel.BeginCloseStream(_streamHandle, null, null);
result.AsyncWaitHandle.WaitOne();
channel.EndCloseStream(result);
}
catch (FaultException <DataphorFault> fault)
{
throw DataphorFaultUtility.FaultToException(fault.Detail);
}
catch (CommunicationException ce)
{
ReportCommunicationError();
throw new ServerException(ServerException.Codes.CommunicationFailure, ErrorSeverity.Environment, ce);
}
}
finally
{
base.Dispose(disposing);
}
}
public IRemoteServerCursor Open(ref RemoteParamData paramsValue, out ProgramStatistics executeTime, out Guid[] bookmarks, int count, out RemoteFetchData fetchData, ProcessCallInfo callInfo)
{
try
{
var channel = GetServiceInterface();
IAsyncResult result = channel.BeginOpenPlanCursorWithFetch(PlanHandle, callInfo, paramsValue, count, null, null);
result.AsyncWaitHandle.WaitOne();
CursorWithFetchResult cursorResult = channel.EndOpenPlanCursorWithFetch(result);
executeTime = cursorResult.ExecuteTime;
_programStatistics = executeTime;
paramsValue.Data = cursorResult.ParamData;
bookmarks = cursorResult.Bookmarks;
fetchData = cursorResult.FetchData;
return(new ClientCursor(this, cursorResult.CursorDescriptor));
}
catch (FaultException <DataphorFault> fault)
{
throw DataphorFaultUtility.FaultToException(fault.Detail);
}
catch (CommunicationException ce)
{
ReportCommunicationError();
throw new ServerException(ServerException.Codes.CommunicationFailure, ErrorSeverity.Environment, ce);
}
}
internal PlanDescriptor GetPlanDescriptor(IRemoteServerStatementPlan plan)
{
PlanDescriptor descriptor = new PlanDescriptor();
descriptor.ID = plan.ID;
descriptor.CacheTimeStamp = plan.Process.Session.Server.CacheTimeStamp;
descriptor.Statistics = plan.PlanStatistics;
descriptor.Messages = DataphorFaultUtility.ExceptionsToFaults(plan.Messages);
return(descriptor);
}
public void Stop()
{
try
{
var channel = GetServiceInterface();
IAsyncResult result = channel.BeginStop(null, null);
result.AsyncWaitHandle.WaitOne();
channel.EndStop(result);
}
catch (FaultException <DataphorFault> fault)
{
throw DataphorFaultUtility.FaultToException(fault.Detail);
}
}
public ClientScript(ClientProcess clientProcess, ScriptDescriptor scriptDescriptor)
{
_clientProcess = clientProcess;
_scriptDescriptor = scriptDescriptor;
_messages = new Exception[_scriptDescriptor.Messages.Count];
for (int index = 0; index < _scriptDescriptor.Messages.Count; index++)
{
_messages[index] = DataphorFaultUtility.FaultToException(_scriptDescriptor.Messages[index]);
}
foreach (BatchDescriptor batchDescriptor in _scriptDescriptor.Batches)
{
_clientBatches.Add(new ClientBatch(this, batchDescriptor));
}
}
public RemoteProposeData Validate(RemoteRowBody oldRow, RemoteRowBody newRow, string column, ProcessCallInfo callInfo)
{
try
{
var channel = GetServiceInterface();
IAsyncResult result = channel.BeginValidate(CursorHandle, callInfo, oldRow, newRow, column, null, null);
result.AsyncWaitHandle.WaitOne();
return(channel.EndValidate(result));
}
catch (FaultException <DataphorFault> fault)
{
throw DataphorFaultUtility.FaultToException(fault.Detail);
}
catch (CommunicationException ce)
{
ReportCommunicationError();
throw new ServerException(ServerException.Codes.CommunicationFailure, ErrorSeverity.Environment, ce);
}
}
public void DisposeBookmarks(Guid[] bookmarks, ProcessCallInfo callInfo)
{
try
{
var channel = GetServiceInterface();
IAsyncResult result = channel.BeginDisposeBookmarks(CursorHandle, callInfo, bookmarks, null, null);
result.AsyncWaitHandle.WaitOne();
channel.EndDisposeBookmarks(result);
}
catch (FaultException <DataphorFault> fault)
{
throw DataphorFaultUtility.FaultToException(fault.Detail);
}
catch (CommunicationException ce)
{
ReportCommunicationError();
throw new ServerException(ServerException.Codes.CommunicationFailure, ErrorSeverity.Environment, ce);
}
}
public void Update(RemoteRow row, System.Collections.BitArray valueFlags, ProcessCallInfo callInfo)
{
try
{
var channel = GetServiceInterface();
IAsyncResult result = channel.BeginUpdate(CursorHandle, callInfo, row, valueFlags, null, null);
result.AsyncWaitHandle.WaitOne();
channel.EndUpdate(result);
}
catch (FaultException <DataphorFault> fault)
{
throw DataphorFaultUtility.FaultToException(fault.Detail);
}
catch (CommunicationException ce)
{
ReportCommunicationError();
throw new ServerException(ServerException.Codes.CommunicationFailure, ErrorSeverity.Environment, ce);
}
}
public void Relinquish(IRemoteServerConnection connection)
{
try
{
var channel = GetServiceInterface();
IAsyncResult result = channel.BeginCloseConnection(((ClientConnection)connection).ConnectionHandle, null, null);
result.AsyncWaitHandle.WaitOne();
channel.EndCloseConnection(result);
}
catch (FaultException <DataphorFault> fault)
{
throw DataphorFaultUtility.FaultToException(fault.Detail);
}
catch (CommunicationException ce)
{
ReportCommunicationError();
throw new ServerException(ServerException.Codes.CommunicationFailure, ErrorSeverity.Environment, ce);
}
}
public IRemoteServerConnection Establish(string connectionName, string hostName)
{
try
{
var channel = GetServiceInterface();
IAsyncResult result = channel.BeginOpenConnection(connectionName, hostName, null, null);
result.AsyncWaitHandle.WaitOne();
return(new ClientConnection(this, connectionName, hostName, channel.EndOpenConnection(result)));
}
catch (FaultException <DataphorFault> fault)
{
throw DataphorFaultUtility.FaultToException(fault.Detail);
}
catch (CommunicationException ce)
{
ReportCommunicationError();
throw new ServerException(ServerException.Codes.CommunicationFailure, ErrorSeverity.Environment, ce);
}
}
public void StopProcess(IRemoteServerProcess process)
{
try
{
var channel = GetServiceInterface();
IAsyncResult result = channel.BeginStopProcess(((ClientProcess)process).ProcessHandle, null, null);
result.AsyncWaitHandle.WaitOne();
channel.EndStopProcess(result);
}
catch (FaultException <DataphorFault> fault)
{
throw DataphorFaultUtility.FaultToException(fault.Detail);
}
catch (CommunicationException ce)
{
ReportCommunicationError();
throw new ServerException(ServerException.Codes.CommunicationFailure, ErrorSeverity.Environment, ce);
}
}
public void Close(IRemoteServerCursor cursor, ProcessCallInfo callInfo)
{
try
{
var channel = GetServiceInterface();
IAsyncResult result = channel.BeginCloseCursor(((ClientCursor)cursor).CursorHandle, callInfo, null, null);
result.AsyncWaitHandle.WaitOne();
channel.EndCloseCursor(result);
}
catch (FaultException <DataphorFault> fault)
{
throw DataphorFaultUtility.FaultToException(fault.Detail);
}
catch (CommunicationException ce)
{
ReportCommunicationError();
throw new ServerException(ServerException.Codes.CommunicationFailure, ErrorSeverity.Environment, ce);
}
}
public RemoteRowBody Select(ProcessCallInfo callInfo)
{
try
{
var channel = GetServiceInterface();
IAsyncResult result = channel.BeginSelect(CursorHandle, callInfo, null, null);
result.AsyncWaitHandle.WaitOne();
return(channel.EndSelect(result));
}
catch (FaultException <DataphorFault> fault)
{
throw DataphorFaultUtility.FaultToException(fault.Detail);
}
catch (CommunicationException ce)
{
ReportCommunicationError();
throw new ServerException(ServerException.Codes.CommunicationFailure, ErrorSeverity.Environment, ce);
}
}
public IRemoteServerSession Connect(SessionInfo sessionInfo)
{
try
{
var channel = GetServiceInterface();
IAsyncResult result = channel.BeginConnect(_connectionHandle, sessionInfo, null, null);
result.AsyncWaitHandle.WaitOne();
return(new ClientSession(this, sessionInfo, channel.EndConnect(result)));
}
catch (FaultException <DataphorFault> fault)
{
throw DataphorFaultUtility.FaultToException(fault.Detail);
}
catch (CommunicationException ce)
{
ReportCommunicationError();
throw new ServerException(ServerException.Codes.CommunicationFailure, ErrorSeverity.Environment, ce);
}
}
public Stream Open(StreamID streamID, LockMode mode)
{
try
{
var channel = GetServiceInterface();
IAsyncResult result = channel.BeginOpenStream(ProcessHandle, streamID, mode, null, null);
result.AsyncWaitHandle.WaitOne();
return(new ClientStream(this, channel.EndOpenStream(result)));
}
catch (FaultException <DataphorFault> fault)
{
throw DataphorFaultUtility.FaultToException(fault.Detail);
}
catch (CommunicationException ce)
{
ReportCommunicationError();
throw new ServerException(ServerException.Codes.CommunicationFailure, ErrorSeverity.Environment, ce);
}
}
public void CommitApplicationTransaction(Guid iD, ProcessCallInfo callInfo)
{
try
{
var channel = GetServiceInterface();
IAsyncResult result = channel.BeginCommitApplicationTransaction(ProcessHandle, callInfo, iD, null, null);
result.AsyncWaitHandle.WaitOne();
channel.EndCommitApplicationTransaction(result);
}
catch (FaultException <DataphorFault> fault)
{
throw DataphorFaultUtility.FaultToException(fault.Detail);
}
catch (CommunicationException ce)
{
ReportCommunicationError();
throw new ServerException(ServerException.Codes.CommunicationFailure, ErrorSeverity.Environment, ce);
}
}
public Guid BeginApplicationTransaction(bool shouldJoin, bool isInsert, ProcessCallInfo callInfo)
{
try
{
var channel = GetServiceInterface();
IAsyncResult result = channel.BeginBeginApplicationTransaction(ProcessHandle, callInfo, shouldJoin, isInsert, null, null);
result.AsyncWaitHandle.WaitOne();
return(channel.EndBeginApplicationTransaction(result));
}
catch (FaultException <DataphorFault> fault)
{
throw DataphorFaultUtility.FaultToException(fault.Detail);
}
catch (CommunicationException ce)
{
ReportCommunicationError();
throw new ServerException(ServerException.Codes.CommunicationFailure, ErrorSeverity.Environment, ce);
}
}
public void Deallocate(StreamID streamID)
{
try
{
var channel = GetServiceInterface();
IAsyncResult result = channel.BeginDeallocateStream(ProcessHandle, streamID, null, null);
result.AsyncWaitHandle.WaitOne();
channel.EndDeallocateStream(result);
}
catch (FaultException <DataphorFault> fault)
{
throw DataphorFaultUtility.FaultToException(fault.Detail);
}
catch (CommunicationException ce)
{
ReportCommunicationError();
throw new ServerException(ServerException.Codes.CommunicationFailure, ErrorSeverity.Environment, ce);
}
}
public Alphora.Dataphor.DAE.Server.ServerFileInfo[] GetFileNames(string className, string environment)
{
try
{
var channel = GetServiceInterface();
IAsyncResult result = channel.BeginGetFileNames(ProcessHandle, className, environment, null, null);
result.AsyncWaitHandle.WaitOne();
return(channel.EndGetFileNames(result));
}
catch (FaultException <DataphorFault> fault)
{
throw DataphorFaultUtility.FaultToException(fault.Detail);
}
catch (CommunicationException ce)
{
ReportCommunicationError();
throw new ServerException(ServerException.Codes.CommunicationFailure, ErrorSeverity.Environment, ce);
}
}
public IRemoteStream GetFile(string libraryName, string fileName)
{
try
{
var channel = GetServiceInterface();
IAsyncResult result = channel.BeginGetFile(ProcessHandle, libraryName, fileName, null, null);
result.AsyncWaitHandle.WaitOne();
return(new ClientStream(this, channel.EndGetFile(result)));
}
catch (FaultException <DataphorFault> fault)
{
throw DataphorFaultUtility.FaultToException(fault.Detail);
}
catch (CommunicationException ce)
{
ReportCommunicationError();
throw new ServerException(ServerException.Codes.CommunicationFailure, ErrorSeverity.Environment, ce);
}
}
public IRemoteServerScript PrepareScript(string script, DebugLocator locator)
{
try
{
var channel = GetServiceInterface();
IAsyncResult result = channel.BeginPrepareScript(ProcessHandle, script, locator, null, null);
result.AsyncWaitHandle.WaitOne();
return(new ClientScript(this, channel.EndPrepareScript(result)));
}
catch (FaultException <DataphorFault> fault)
{
throw DataphorFaultUtility.FaultToException(fault.Detail);
}
catch (CommunicationException ce)
{
ReportCommunicationError();
throw new ServerException(ServerException.Codes.CommunicationFailure, ErrorSeverity.Environment, ce);
}
}
public void UnprepareScript(IRemoteServerScript script)
{
try
{
var channel = GetServiceInterface();
IAsyncResult result = channel.BeginUnprepareScript(((ClientScript)script).ScriptHandle, null, null);
result.AsyncWaitHandle.WaitOne();
channel.EndUnprepareScript(result);
}
catch (FaultException <DataphorFault> fault)
{
throw DataphorFaultUtility.FaultToException(fault.Detail);
}
catch (CommunicationException ce)
{
ReportCommunicationError();
throw new ServerException(ServerException.Codes.CommunicationFailure, ErrorSeverity.Environment, ce);
}
}
public override void SetLength(long tempValue)
{
try
{
var channel = GetServiceInterface();
IAsyncResult result = channel.BeginSetStreamLength(_streamHandle, tempValue, null, null);
result.AsyncWaitHandle.WaitOne();
channel.EndSetStreamLength(result);
}
catch (FaultException <DataphorFault> fault)
{
throw DataphorFaultUtility.FaultToException(fault.Detail);
}
catch (CommunicationException ce)
{
ReportCommunicationError();
throw new ServerException(ServerException.Codes.CommunicationFailure, ErrorSeverity.Environment, ce);
}
}
public string GetText()
{
try
{
var channel = GetServiceInterface();
IAsyncResult result = channel.BeginGetBatchText(BatchHandle, null, null);
result.AsyncWaitHandle.WaitOne();
return(channel.EndGetBatchText(result));
}
catch (FaultException <DataphorFault> fault)
{
throw DataphorFaultUtility.FaultToException(fault.Detail);
}
catch (CommunicationException ce)
{
ReportCommunicationError();
throw new ServerException(ServerException.Codes.CommunicationFailure, ErrorSeverity.Environment, ce);
}
}
public IRemoteServerExpressionPlan PrepareExpression(string expression, RemoteParam[] paramsValue, DebugLocator locator, out PlanDescriptor planDescriptor, RemoteProcessCleanupInfo cleanupInfo)
{
try
{
var channel = GetServiceInterface();
IAsyncResult result = channel.BeginPrepareExpression(ProcessHandle, GetCleanupInfo(cleanupInfo), expression, paramsValue, locator, null, null);
result.AsyncWaitHandle.WaitOne();
planDescriptor = channel.EndPrepareExpression(result);
return(new ClientExpressionPlan(this, planDescriptor));
}
catch (FaultException <DataphorFault> fault)
{
throw DataphorFaultUtility.FaultToException(fault.Detail);
}
catch (CommunicationException ce)
{
ReportCommunicationError();
throw new ServerException(ServerException.Codes.CommunicationFailure, ErrorSeverity.Environment, ce);
}
}
public void Execute(string statement, ref RemoteParamData paramsValue, ProcessCallInfo callInfo, RemoteProcessCleanupInfo cleanupInfo)
{
try
{
var channel = GetServiceInterface();
IAsyncResult result = channel.BeginExecuteStatement(ProcessHandle, GetCleanupInfo(cleanupInfo), callInfo, statement, paramsValue, null, null);
result.AsyncWaitHandle.WaitOne();
ExecuteResult executeResult = channel.EndExecuteStatement(result);
paramsValue.Data = executeResult.ParamData;
}
catch (FaultException <DataphorFault> fault)
{
throw DataphorFaultUtility.FaultToException(fault.Detail);
}
catch (CommunicationException ce)
{
ReportCommunicationError();
throw new ServerException(ServerException.Codes.CommunicationFailure, ErrorSeverity.Environment, ce);
}
}
public static ProcessCleanupInfo GetCleanupInfo(RemoteProcessCleanupInfo cleanupInfo)
{
try
{
ProcessCleanupInfo localCleanupInfo = new ProcessCleanupInfo();
localCleanupInfo.UnprepareList = new int[cleanupInfo.UnprepareList.Length];
for (int index = 0; index < localCleanupInfo.UnprepareList.Length; index++)
{
localCleanupInfo.UnprepareList[index] = ((ClientPlan)cleanupInfo.UnprepareList[index]).PlanHandle;
}
return(localCleanupInfo);
}
catch (FaultException <DataphorFault> fault)
{
throw DataphorFaultUtility.FaultToException(fault.Detail);
}
catch (CommunicationException ce)
{
throw new ServerException(ServerException.Codes.CommunicationFailure, ErrorSeverity.Environment, ce);
}
}
public RemoteFetchData Fetch(RemoteRowHeader header, out Guid[] bookmarks, int count, bool skipCurrent, ProcessCallInfo callInfo)
{
try
{
var channel = GetServiceInterface();
IAsyncResult result = channel.BeginFetchSpecific(CursorHandle, callInfo, header, count, skipCurrent, null, null);
result.AsyncWaitHandle.WaitOne();
FetchResult fetchResult = channel.EndFetchSpecific(result);
bookmarks = fetchResult.Bookmarks;
return(fetchResult.FetchData);
}
catch (FaultException <DataphorFault> fault)
{
throw DataphorFaultUtility.FaultToException(fault.Detail);
}
catch (CommunicationException ce)
{
ReportCommunicationError();
throw new ServerException(ServerException.Codes.CommunicationFailure, ErrorSeverity.Environment, ce);
}
}