private void Dispose(bool disposing)
{
if (disposing)
{
if (m_portfolio != null)
{
m_portfolio.Dispose();
m_portfolio = null;
}
if (m_indices != null)
{
m_indices.Dispose();
m_indices = null;
}
if (m_messageUtilities1 != null)
{
m_messageUtilities1.Dispose();
m_messageUtilities1 = null;
}
if (m_messageUtilities2 != null)
{
m_messageUtilities2.Dispose();
m_messageUtilities2 = null;
}
PositionMonitorUtilities.Info(Name + " disposed");
}
}
private bool ManageSubscriptions(List <HugoDataSet.PortfolioRow> subscribeList, List <string> unsubscribeList)
{
try
{
if (IsSubscribed)
{
if (subscribeList.Count > 0)
{
foreach (HugoDataSet.PortfolioRow row in subscribeList)
{
m_messageUtilities1.Subscribe(row.Symbol, row.QuoteType, row);
PositionMonitorUtilities.Info(String.Format("{0} now subscribed to {1}", Name, row.Symbol));
}
PositionMonitorUtilities.Info(String.Format("{0} subscribed to {1} new symbols", Name, subscribeList.Count));
}
if (unsubscribeList.Count > 0)
{
foreach (string ticker in unsubscribeList)
{
m_messageUtilities1.Unsubscribe(ticker);
PositionMonitorUtilities.Info(String.Format("{0} now unsubscribed from {1}", Name, ticker));
}
PositionMonitorUtilities.Info(String.Format("{0} unsubscribed from {1} symbols", Name, unsubscribeList.Count));
}
}
return(true);
}
catch (Exception ex)
{
PositionMonitorUtilities.Error(Name + " unable to manage subscriptions", ex);
return(false);
}
}
// should call StartSubsriber() after calling Start()
public bool Start()
{
try
{
if (!IsStarted)
{
if (!m_monitorUtilities.IsMonitoring)
{
PositionMonitorUtilities.Info(String.Format("Cannot start {0} before starting monitor", Name));
}
else
{
RefreshEventArgs args = new RefreshEventArgs(true);
UpdateTables(args);
m_monitorUtilities.OnRefresh += utilities_OnRefresh;
IsStarted = true;
}
}
}
catch (Exception ex)
{
PositionMonitorUtilities.Error("Unable to start " + Name, ex);
IsStarted = false;
}
return(IsStarted);
}
public bool StartSubscriber()
{
try
{
lock (m_quoteServerLock)
{
if (!IsSubscribed)
{
// start two subscribers - one for positions and one for indices (necessary in case there is an overlap)
IsSubscribed = m_messageUtilities1.StartSubscriber(m_monitorUtilities.QuoteServerHost, m_monitorUtilities.QuoteServerPort) &&
m_messageUtilities2.StartSubscriber(m_monitorUtilities.QuoteServerHost, m_monitorUtilities.QuoteServerPort);
if (IsSubscribed)
{
QuoteServiceStoppedTime = null;
int rowCount;
lock (m_portfolioLock)
{
rowCount = 0;
foreach (HugoDataSet.PortfolioRow row in m_portfolio.Rows)
{
if (!row.IsCurrent_PositionNull())
{
int sodPosition = row.IsSOD_PositionNull() ? 0 : row.SOD_Position;
if ((row.Current_Position != 0) || (sodPosition != 0) || (row.IsStock == 1))
{
row.SubscriptionStatus = SubscriptionStatus.Subscribed.ToString();
m_messageUtilities1.Subscribe(row.Symbol, row.QuoteType, row);
rowCount++;
}
}
}
PositionMonitorUtilities.Info(String.Format("{0} subscribed to {1} position symbols, host={2}", Name, rowCount, m_monitorUtilities.QuoteServerHost));
rowCount = 0;
foreach (HugoDataSet.IndicesRow row in m_indices.Rows)
{
QuoteType quoteType = row.IndexFlag ? QuoteType.Index : QuoteType.Stock;
row.SubscriptionStatus = SubscriptionStatus.Subscribed.ToString();
m_messageUtilities2.Subscribe(row.Symbol, quoteType, row);
rowCount++;
}
PositionMonitorUtilities.Info(String.Format("{0} subscribed to {1} index symbols, host={2}", Name, rowCount, m_monitorUtilities.QuoteServerHost));
}
}
}
}
}
catch (Exception ex)
{
PositionMonitorUtilities.Error(Name + " unable to subscribe to market data", ex);
StopSubscriber();
}
return(IsSubscribed);
}
private bool UpdateIndices(HugoDataSet.IndexWeightsRow[] rows)
{
try
{
List <HugoDataSet.IndicesRow> subscribeList = new List <HugoDataSet.IndicesRow>();
lock (m_portfolioLock)
{
m_indexWeights = rows;
foreach (HugoDataSet.IndexWeightsRow indexWeightsRow in rows)
{
HugoDataSet.IndicesRow indicesRow = m_indices.Rows.Find(new string[] { indexWeightsRow.AcctName, indexWeightsRow.Symbol }) as HugoDataSet.IndicesRow;
if (indicesRow == null)
{
indicesRow = m_indices.NewIndicesRow();
indicesRow.AcctName = indexWeightsRow.AcctName;
indicesRow.Symbol = indexWeightsRow.Symbol;
m_indices.Rows.Add(indicesRow);
}
indicesRow.Weight = indexWeightsRow.Weight;
indicesRow.IndexFlag = indexWeightsRow.IndexFlag;
if (IsSubscribed && (indicesRow.SubscriptionStatus != SubscriptionStatus.Subscribed.ToString()))
{
indicesRow.SubscriptionStatus = SubscriptionStatus.Subscribed.ToString();
subscribeList.Add(indicesRow);
}
}
}
if (IsSubscribed)
{
if (subscribeList.Count > 0)
{
foreach (HugoDataSet.IndicesRow row in subscribeList)
{
QuoteType quoteType = row.IndexFlag ? QuoteType.Index : QuoteType.Stock;
m_messageUtilities2.Subscribe(row.Symbol, quoteType, row);
PositionMonitorUtilities.Info(String.Format("{0} now subscribed to {1} as {2}", Name, row.Symbol, quoteType.ToString()));
}
PositionMonitorUtilities.Info(String.Format("{0} subscribed to {1} new indices", Name, subscribeList.Count));
}
}
}
catch (Exception ex)
{
PositionMonitorUtilities.Error(String.Format("{0} unable to fill indices table", Name), ex);
return(false);
}
return(true);
}
private bool UpdateBenchmark(string symbol, QuoteType quoteType)
{
try
{
if (!String.IsNullOrEmpty(symbol))
{
if (symbol == "SPXT")
{
symbol = "SPX";
}
bool subscribe = false;
HugoDataSet.IndicesRow benchmarkRow = null;
lock (m_portfolioLock)
{
benchmarkRow = m_indices.Rows.Find(new string[] { AccountName, symbol }) as HugoDataSet.IndicesRow;
if (benchmarkRow == null)
{
benchmarkRow = m_indices.NewIndicesRow();
benchmarkRow.AcctName = AccountName;
benchmarkRow.Symbol = symbol;
benchmarkRow.IndexFlag = (quoteType == QuoteType.Index);
m_indices.Rows.Add(benchmarkRow);
}
if (IsSubscribed && (benchmarkRow.SubscriptionStatus != SubscriptionStatus.Subscribed.ToString()))
{
benchmarkRow.SubscriptionStatus = SubscriptionStatus.Subscribed.ToString();
subscribe = true;
}
}
if (subscribe)
{
m_messageUtilities1.Subscribe(benchmarkRow.Symbol, quoteType, benchmarkRow);
PositionMonitorUtilities.Info(String.Format("{0} now subscribed to {1} as benchmark", Name, benchmarkRow.Symbol));
}
}
}
catch (Exception ex)
{
PositionMonitorUtilities.Error(String.Format("{0} unable to subscribe to benchmark {1}", Name, symbol), ex);
return(false);
}
return(true);
}
private void m_messageUtilities_OnReaderStopped(object sender, ServiceStoppedEventArgs e)
{
if (e.Exception == null)
{
PositionMonitorUtilities.Info(e.Message);
}
else
{
PositionMonitorUtilities.Error(e.Message, e.Exception);
}
StopSubscriber();
if (m_refreshEventHandler != null)
{
m_refreshEventHandler(this, new EventArgs());
}
}
private void m_messageUtilities_OnInfo(object sender, LoggingEventArgs e)
{
PositionMonitorUtilities.Info(e.Message);
}
