public UserQuitEventArgs(IUser user, IChannel channel, IServer server, string reason = null)
{
this.User = user;
this.Channel = channel;
this.Server = server;
this.Reason = reason;
}
/// <summary>
/// Uruchamia grę.
/// </summary>
public void Start()
{
this.Server = new TcpServer(ServerConfiguration.Instance.Port, ServerConfiguration.Instance.MaxSpectators + 2,
ServerConfiguration.Instance.Name, System.Reflection.Assembly.GetExecutingAssembly().GetName().Version,
ServerConfiguration.Instance.InfoPort);
this.Server.Start();
this.TimeLeft = (this.TimeLeft2 = ServerConfiguration.Instance.WaitTime) + Settings.WaitTimeDelay;
Stopwatch watch = new Stopwatch();
double old = watch.Elapsed.TotalSeconds;
while (!this.StopMainLoop)
{
double delta = watch.Elapsed.TotalSeconds - old;
old = watch.Elapsed.TotalSeconds;
this.ProcessClients(delta);
this.ProcessOther(delta);
if (this.InGame)
this.ProcessInGame(delta);
else
this.ProcessNonInGame(delta);
}
watch.Stop();
this.Server.Stop();
}
public Account(string username, string passwordHash, ICountry country, IServer server)
{
Username = username;
PasswordHash = passwordHash;
Country = country;
Server = server;
}
public void AddServer(IServer server)
{
TreeIter iter = Store.Append();
//Store.SetValue(iter, 0, new Gdk.Pixbuf...)
Store.SetValue(iter, 1, server.Name);
Store.SetValue(iter, 2, server);
}
protected static void RemoveMethodFromNewClientEvent(IServer server, ClientConnectedEventHandler clientConnectedEventHandler)
{
lock (clientConnectedEventHandler)
{
server.NewClientEvent -= clientConnectedEventHandler;
}
}
protected static void AddMethodToNewClientEvent(IServer server, ClientConnectedEventHandler clientConnectedEventHandler)
{
lock (newClientEventMonitor)
{
server.NewClientEvent += clientConnectedEventHandler;
}
}
public Connector(IServer server, string ip, int port)
{
Connections = new List<IWebSocketConnection>();
_server = server;
_ip = ip;
_port = port;
}
public void Run()
{
_server = new TcpipServer(new IPEndPoint(IPAddress.Any, 12345));
_server.NewClient = ch =>
{
_serverService = new Service(ch);
_serverService.RegisterLocalService<Func<Task>>(ServerAction);
};
_server.StartListening();
_client = new TcpipClient(new IPEndPoint(IPAddress.Loopback, 12345));
_clientService = new Service(_client);
_clientService.OnNewRemoteService.Subscribe(s =>
{
Console.WriteLine("NewRemoteService {0}", s);
_clientFunc = _clientService.QueryRemoteService<Func<Task>>();
});
_client.ConnectAsync();
while (_clientFunc==null)
{
Thread.Sleep(1);
}
_clientFunc().Wait();
_serverService.Dispose();
try
{
_clientFunc().Wait();
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
_server.StopListening();
}
/// <summary>
/// Add an socket to "server"-Server-Instance and register it
/// </summary>
/// <param name="ep">Socket to register</param>
/// <param name="server">Server-Instance</param>
public BaseConnection(Socket client, IServer server)
{
if (client == null)
throw new ArgumentNullException("client");
if (server == null)
throw new ArgumentNullException("server");
// this._encoding = Encoding.GetEncoding(28591);// iso_8859-1
this.handler = client;
this._server = server;
/*
int id = this.rnd.Next();
while (server.HasID(id) || server.SeedID(id)) // new seed id
{
id = this.rnd.Next();
}
this._id = id;
#if UNSTABLE
SocketManager socketManager = ((BaseServer)this._server).SocketManager;
socketManager.AddConnection(this);
#else
ThreadPool.QueueUserWorkItem(new WaitCallback(this.RecieveProc), null); // to/do: 25 Thread Limit!!!!
#endif
this.available = true;
Console.WriteLine("new BaseConnection with id: {0}, is availbale", id);*/
this.Initialize();
}
public void TestFixtureSetup()
{
var configuration = new ClientConfiguration();
var connectionPool = new ConnectionPool<EapConnection>(new PoolConfiguration(), UriExtensions.GetEndPoint(Address));
var ioStrategy = new DefaultIOStrategy(connectionPool);
_server = new Server(ioStrategy, new Node(), configuration);
}
private void btnListen_Click(object sender, EventArgs e)
{
if (rbUdp.Checked)
commServer = new CommUdpServer();
int port = int.Parse(this.txtPort.Text);
commServer.Init(null, port);
commServer.OnDataReceived += new ReceivedHandler(ListenMessage);
commServer.OnSocketError += new SocketErrorHandler(ListenErrorMessage);
//refreshThread = new Thread(new ThreadStart(RefreshConnection));
if(refreshConnectionWorker.IsBusy == false)
refreshConnectionWorker.RunWorkerAsync();
try
{
commServer.Listen();
btnListen.Enabled = false;
btnStopListen.Enabled = true;
ListenMessage(0, "", "启动监听成功,端口:" + port);
}
catch (Exception ex)
{
MessageBox.Show("监听失败，端口可能被占用");
}
}
public void OnClose(IServer server)
{
NumOnCloseEvents++;
if (OnCloseAction != null)
OnCloseAction();
}
/// <summary>
/// Generates a complete new ring into the provided <paramref name="ring" /> dataset. This should produce a complete 24 hour active ring which has no
/// other logic then playing the right things at the right time, independet of the past.
/// </summary>
/// <param name="server">The source database</param>
/// <param name="computerName">The name of the computer this ring is generated for.</param>
/// <param name="ring">The target ring where all the generated data should be inserted at.</param>
/// <remarks>
/// Things which need to be done:
/// <para>Set <see cref="RingMetaData.SenderId" /> to the targeting sender id.</para>
/// <para>Generate <see cref="PageGroup" />s inside the database.</para>
/// <para>
/// Generate <see cref="Page" />s with the associated content (<see cref="Text" />, <see cref="Image" /> <see cref="Video" />,
/// <see cref="DoubleTransition" />).
/// </para>
/// <para>
/// Generate <see cref="PageSchedule" />s. <see cref="PageSchedule" />s in sequence which belongs to the same <see cref="PageGroup" /> needs to
/// have the same <see cref="PageSchedule.PageGroupScheduleId" />.
/// </para>
/// </remarks>
public void Generate(IServer server, string computerName, RingMetaData ring)
{
//if (DateTime.Now - server.Load<DateTime>("LastRefresh") > TimeSpan.FromDays(1))
// server.Save(StorageEnum.MultiMedia, null);
//server.Save(StorageEnum.MultiMedia, null); //TODO Clears the current multimedia db
MultiMedia db = GetMultiMedia(server);
MMSender sender = GetMMSenderFromSenderOrComputerName(db, computerName);
ring.Occasion = sender.NameId;
ring.SenderId = sender.Id;
sender.DataSet.SetHasBeenLoaded();
DistributionRoot DistributionRootInstance = new DistributionRoot(db,ring.TargetDate);
DistributionRootInstance.PreloadAllForAllTodayAndTomorrowMMunitsIfNotHasBeenLoaded();
BalancerUsage balancerUsage = new BalancerUsage(sender, ring, ring.TargetDate)
{
TodaysActiveMMUnitsPerMMSlot = DistributionRootInstance.TodayActiveMMUnitsPerMMSlot
};
balancerUsage.LoadActuallBalancers(sender);
RingGenerator ringGenerator = new RingGenerator(sender, ring, ring.TargetDate)
{
DistributionRootInstance = DistributionRootInstance,
TodaysBalancers = (balancerUsage.TodaysBalancersPerSender.ContainsKey(sender))
? balancerUsage.TodaysBalancersPerSender[sender] : null
};
ringGenerator.Generate();
}
/// <summary>
/// Initializes a new instance of the <see cref="Database"/> class.
/// </summary>
/// <param name="server">The server.</param>
/// <param name="binding">The binding.</param>
public Database(IServer server, IDBBinding binding)
{
Server = server;
Uri relative = binding.Uri.IsAbsoluteUri ? server.Uri.MakeRelativeUri(binding.Uri) : binding.Uri;
Uri = new Uri(server.Uri, relative);
Binding = binding;
}
public LinqEditorViewModel(IServer server)
{
DisplayName = "Query";
this.server = server;
Query = "from doc in docs " + Environment.NewLine + "select doc";
}
public EditCollectionTemplateViewModel(IServer server, IEventAggregator events,
IDocumentTemplateProvider templateProvider)
{
this.server = server;
this.events = events;
this.templateProvider = templateProvider;
}
protected ConsoleOutputTask(IServer server, IEventAggregator events)
: base(events)
{
this.server = server;
Console = new BindableCollection<string>();
server.CurrentDatabaseChanged += delegate { ClearConsole(); };
}
public ClientManager(IServer server, ICommandQueueService commandQueueService, ICommandSerializer commandSerializer, IStreamIOService streamIoService)
{
_server = server;
_commandQueueService = commandQueueService;
_commandSerializer = commandSerializer;
_streamIoService = streamIoService;
}
public PacketManager(TextWriter logger, IServer server)
{
Logger = logger;
Server = server;
_packetHandlers = new Dictionary<DataIdentifier, Func<EndPoint, ChatPacket, ChatPacket>>();
}
public PadInt(int txid, int uid, IServer server, int version)
{
_txid = txid;
_uid = uid;
_server = server;
_version = version;
}
/// <summary>
/// Starts the specified server.
/// </summary>
/// <param name="server">The server.</param>
public void Start(IServer server)
{
RequiresNotNull(server);
var instructions = new BuildInstructions(Guid.Empty, string.Empty, string.Empty);
try
{
instructions = GetBuildInstructions(server);
BuildProject(server, instructions);
ExecuteNUnitTestRunner(server, instructions);
}
catch (FileNotFoundException e)
{
log.Log(LogSeverity.Error, $"The file was not found: {e.FileName}");
var status = new ClientInformation(Environment.MachineName, instructions.Session, BuildStatus.Failed,
new TestResult[0]);
server.UpdateClientStatus(status);
}
catch (Win32Exception e)
{
log.Log(LogSeverity.Error, $"Error launching the build process: {e.Message}");
var status = new ClientInformation(Environment.MachineName, instructions.Session, BuildStatus.Failed,
new TestResult[0]);
server.UpdateClientStatus(status);
}
catch (ApplicationException e)
{
log.Log(LogSeverity.Error, $"Error building the project: {e.Message}");
var status = new ClientInformation(Environment.MachineName, instructions.Session, BuildStatus.Failed,
new TestResult[0]);
server.UpdateClientStatus(status);
}
}
public int Read()
{
int value;
try
{
value = _server.ReadValue(_version, _txid, _uid);
}
catch (WrongVersionException)
{
PadiDstm.UpdateServers();
PadInt newPadInt = PadiDstm.GetPadInt(_uid);
_server = newPadInt._server;
_version = newPadInt._version;
value = newPadInt.Read();
}
catch (SocketException)
{
PadInt newPadInt = PadiDstm.GetBackupPadInt(_uid);
_server = newPadInt._server;
_version = newPadInt._version;
value = newPadInt.Read();
}
return value;
}
public void Use(IServer server, string commandName, string[] tokens)
{
if (tokens.Length < 1)
{
Help(server);
return;
}
var toKick = server.GetClients();
if (toKick.Any() && tokens[0].ToLower() != "all")
{
foreach (var client1 in toKick.Where(client1 => !client1.GetOwner().CanUseCommand("chraft.kick.exempt")))
{
client1.Kick(tokens.Length > 1 ? tokens[1] : "Kicked");
server.GetLogger().Log(LogLevel.Info, "Kicked " + client1.GetOwner().Name);
}
}
else
{
foreach (IClient t in toKick.Where(t => t.GetOwner().Name.ToLower() == tokens[0].ToLower()).Where(t => !t.GetOwner().CanUseCommand("chraft.kick.exempt")))
{
t.Kick(tokens.Length > 1 ? tokens[1] : "Kicked");
server.GetLogger().Log(LogLevel.Info, "Kicked " + t.GetOwner().Name);
}
}
}
public void Run(int port) {
using (var mefContainer = SetupMefContainer()) {
var server = mefContainer.GetExportedValue<IServer>();
Instance = server; // For debugging only.
server.Run(port);
}
}
private Model GetModel(IServer server)
{
RequiresNotNull(server);
var r = server.PollCurrentStatus();
var model = new Model(r);
return model;
}
public SelectDatabaseViewModel(IServer server, IEventAggregator events)
: base(events)
{
DisplayName = "Home";
Server = server;
ShowCreateDatabaseForm = Visibility.Collapsed;
}
public Client(IServer server, TcpClient client)
{
Server = server;
Processor = new ServerPacketProcessor();
this.client = client;
stream = client.GetStream();
thread = new Thread(Main);
}
/// <summary>
/// Initialisiert eine neue NetworkAnnouncerBase-Klasse unter verwendung eines IServer-Objektes.
/// </summary>
/// <param name="server">Das zu verwendene ISever-Objekt.</param>
public NetworkAnnouncerBase(IServer server)
{
Server = server;
Announcing = false;
Interval = 3000;
AnnouncingPort = 15000;
UpdateHostData();
}
public ISocketDelegate OnConnection(IServer server, ISocket socket)
{
// XXX freelist
var txDel = new HttpServerTransactionDelegate(responseFactory, requestDelegate);
var socketDelegate = new HttpServerSocketDelegate(txDel);
socketDelegate.Start(socket);
return socketDelegate;
}
public ISocketDelegate OnConnection(IServer server, ISocket socket)
{
var txDel = new HttpServerTransactionDelegate(socket.RemoteEndPoint.Address, responseFactory, requestDelegate);
var delWrapper = new HttpServerTransactionDelegateWrapper(txDel, connWatcher, socket);
var socketDelegate = new IosHttpServerSocketDelegate(delWrapper);
socketDelegate.Start(socket);
return socketDelegate;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="c">Client reference</param>
/// <param name="s">Server reference</param>
public SelectLocale(IBBSClient c, IServer s) : this(c, s, defaultText, null)
{
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="c">Client reference</param>
/// <param name="s">Server reference</param>
/// <param name="prev">Link to caller screen</param>
public SelectLocale(IBBSClient c, IServer s, IScreen prev) : this(c, s, defaultText, prev)
{
}
public void ShowDependenciesCommand(Guid resourceId, IServer server, bool isSource)
{
_shellViewModel.ShowDependencies(resourceId, server, isSource);
}
/// <summary>
/// выгружает счета на форму
/// </summary>
private void LoadPortfolioOnBox()
{
try
{
List <IServer> serversAll = ServerMaster.GetServers();
IServer server = serversAll.Find(server1 => server1.ServerType == _selectedType);
if (server == null)
{
return;
}
if (!ComboBoxClass.CheckAccess())
{
ComboBoxClass.Dispatcher.Invoke(LoadPortfolioOnBox);
return;
}
string curPortfolio = null;
if (ComboBoxPortfolio.SelectedItem != null)
{
curPortfolio = ComboBoxPortfolio.SelectedItem.ToString();
}
ComboBoxPortfolio.Items.Clear();
string portfolio = _connectorBot.PortfolioName;
if (portfolio != null)
{
ComboBoxPortfolio.Items.Add(_connectorBot.PortfolioName);
ComboBoxPortfolio.Text = _connectorBot.PortfolioName;
}
List <Portfolio> portfolios = server.Portfolios;
if (portfolios == null)
{
return;
}
for (int i = 0; i < portfolios.Count; i++)
{
bool isInArray = false;
for (int i2 = 0; i2 < ComboBoxPortfolio.Items.Count; i2++)
{
if (ComboBoxPortfolio.Items[i2].ToString() == portfolios[i].Number)
{
isInArray = true;
}
}
if (isInArray == true)
{
continue;
}
ComboBoxPortfolio.Items.Add(portfolios[i].Number);
}
if (curPortfolio != null)
{
for (int i = 0; i < ComboBoxPortfolio.Items.Count; i++)
{
if (ComboBoxPortfolio.Items[i].ToString() == curPortfolio)
{
ComboBoxPortfolio.SelectedItem = curPortfolio;
break;
}
}
}
}
catch (Exception error)
{
SendNewLogMessage(error.ToString(), LogMessageType.Error);
}
}
public ServerAddressesMiddleware(RequestDelegate _, IServer server)
{
_features = server.Features;
}
public SchedulerViewModel(IEventAggregator eventPublisher, DirectoryObjectPickerDialog directoryObjectPicker, IPopupController popupController, IAsyncWorker asyncWorker, IServer server, Func <IServer, IServer> toEnvironmentModel, Task <IResourcePickerDialog> getResourcePicker)
: base(eventPublisher)
{
SchedulerTaskManager = new SchedulerTaskManager(this, getResourcePicker);
VerifyArgument.IsNotNull("directoryObjectPicker", directoryObjectPicker);
var directoryObjectPicker1 = directoryObjectPicker;
VerifyArgument.IsNotNull("popupController", popupController);
_popupController = popupController;
VerifyArgument.IsNotNull("asyncWorker", asyncWorker);
_asyncWorker = asyncWorker;
_toEnvironmentModel = toEnvironmentModel ?? (a => a.ToEnvironmentModel());
Errors = new ErrorResultTO();
IsLoading = false;
directoryObjectPicker1.AllowedObjectTypes = ObjectTypes.Users;
directoryObjectPicker1.DefaultObjectTypes = ObjectTypes.Users;
directoryObjectPicker1.AllowedLocations = Locations.All;
directoryObjectPicker1.DefaultLocations = Locations.JoinedDomain;
directoryObjectPicker1.MultiSelect = false;
directoryObjectPicker1.TargetComputer = string.Empty;
directoryObjectPicker1.ShowAdvancedView = false;
InitializeHelp();
var serverRepository = CustomContainer.Get <IServerRepository>();
DebugOutputViewModel = new DebugOutputViewModel(new EventPublisher(), serverRepository, new DebugOutputFilterStrategy());
Server = server;
SetupServer(server);
SetDisplayName(false);
}
public ResourceDesignerViewModel(IContextualResourceModel model, IServer server)
{
_contexttualResourceModel = model;
_server = server;
}
public AppExceptionPopupController(IServer environment)
{
_environment = environment;
}
public ExchangeEmailDesignerViewModel(ModelItem modelItem, IAsyncWorker asyncWorker, IServer server, IEventAggregator eventPublisher)
: base(modelItem)
{
VerifyArgument.IsNotNull("asyncWorker", asyncWorker);
VerifyArgument.IsNotNull("eventPublisher", eventPublisher);
_asyncWorker = asyncWorker;
_server = server;
_eventPublisher = eventPublisher;
_eventPublisher.Subscribe(this);
AddTitleBarLargeToggle();
TestEmailAccountCommand = new RelayCommand(o => TestEmailAccount(), o => CanTestEmailAccount);
ChooseAttachmentsCommand = new DelegateCommand(o => ChooseAttachments());
var shellViewModel = CustomContainer.Get <IShellViewModel>();
var model = CustomContainer.CreateInstance <IExchangeServiceModel>(server.UpdateRepository, server.QueryProxy, shellViewModel, server);
Model = model;
SetupCommonProperties();
HelpText = Warewolf.Studio.Resources.Languages.HelpText.Tool_Email_Exchange_Send;
}
public Application(IServer server)
{
this.server = server;
db = DbFactory.Create();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="c">Client reference</param>
/// <param name="s">Server reference</param>
/// <param name="txt">Text to parse and optional parameters separated by semicolon</param>
public SelectLocale(IBBSClient c, IServer s, string txt) : this(c, s, txt, null)
{
}
/// <summary>
/// поместить классы в окно
/// </summary>
private void LoadClassOnBox()
{
try
{
if (!ComboBoxClass.Dispatcher.CheckAccess())
{
ComboBoxClass.Dispatcher.Invoke(LoadClassOnBox);
return;
}
List <IServer> serversAll = ServerMaster.GetServers();
IServer server = serversAll.Find(server1 => server1.ServerType == _selectedType);
if (server == null)
{
return;
}
if (ComboBoxClass.Items.Count != 0)
{
ComboBoxClass.Items.Clear();
}
var securities = server.Securities;
ComboBoxClass.Items.Clear();
if (securities == null)
{
return;
}
for (int i1 = 0; i1 < securities.Count; i1++)
{
string clas = securities[i1].NameClass;
if (ComboBoxClass.Items.Count == 0)
{
ComboBoxClass.Items.Add(clas);
continue;
}
bool isInArray = false;
for (int i = 0; i < ComboBoxClass.Items.Count; i++)
{
string item = ComboBoxClass.Items[i].ToString();
if (item == clas)
{
isInArray = true;
break;
}
}
if (isInArray == false)
{
ComboBoxClass.Items.Add(clas);
}
}
if (_connectorBot.Security != null)
{
ComboBoxClass.SelectedItem = _connectorBot.Security.NameClass;
}
}
catch (Exception error)
{
SendNewLogMessage(error.ToString(), LogMessageType.Error);
}
}
public WebHostService(IOptions <WebHostServiceOptions> options, IServiceProvider services, HostBuilderContext hostBuilderContext, IServer server,
ILogger <WebHostService> logger, DiagnosticListener diagnosticListener, IHttpContextFactory httpContextFactory)
{
Options = options?.Value ?? throw new System.ArgumentNullException(nameof(options));
if (Options.ConfigureApp == null)
{
throw new ArgumentException(nameof(Options.ConfigureApp));
}
Services = services ?? throw new ArgumentNullException(nameof(services));
HostBuilderContext = hostBuilderContext ?? throw new ArgumentNullException(nameof(hostBuilderContext));
Server = server ?? throw new ArgumentNullException(nameof(server));
Logger = logger ?? throw new ArgumentNullException(nameof(logger));
DiagnosticListener = diagnosticListener ?? throw new ArgumentNullException(nameof(diagnosticListener));
HttpContextFactory = httpContextFactory ?? throw new ArgumentNullException(nameof(httpContextFactory));
}
/// <summary>
/// перерисовать таблицу источников
/// </summary>
private void RePaintSourceGrid()
{
if (_gridSources.InvokeRequired)
{
_gridSources.Invoke(new Action(RePaintSourceGrid));
return;
}
_gridSources.Rows.Clear();
List <ServerType> servers = new ServerType[]
{
ServerType.Finam, ServerType.QuikDde, ServerType.QuikLua, ServerType.SmartCom, ServerType.Plaza,
ServerType.Oanda, ServerType.BitMex, ServerType.Kraken, ServerType.Binance, ServerType.BitStamp, ServerType.NinjaTrader
}.ToList();
List <IServer> serversCreate = ServerMaster.GetServers();
if (serversCreate == null)
{
serversCreate = new List <IServer>();
}
for (int i = 0; i < servers.Count; i++)
{
DataGridViewRow row1 = new DataGridViewRow();
row1.Cells.Add(new DataGridViewTextBoxCell());
row1.Cells[0].Value = servers[i];
row1.Cells.Add(new DataGridViewTextBoxCell());
IServer server = serversCreate.Find(s => s.ServerType == servers[i]);
if (server == null)
{
row1.Cells[1].Value = "Disabled";
}
else if (server != null && server.ServerStatus == ServerConnectStatus.Connect)
{
row1.Cells[1].Value = "Connect";
DataGridViewCellStyle style = new DataGridViewCellStyle();
style.BackColor = Color.MediumSeaGreen;
style.SelectionBackColor = Color.Green;
style.ForeColor = Color.Black;
style.SelectionForeColor = Color.Black;
row1.Cells[1].Style = style;
row1.Cells[0].Style = style;
}
else
{
row1.Cells[1].Value = "Disconnect";
DataGridViewCellStyle style = new DataGridViewCellStyle();
style.BackColor = Color.Coral;
style.SelectionBackColor = Color.Chocolate;
style.ForeColor = Color.Black;
style.SelectionForeColor = Color.Black;
row1.Cells[1].Style = style;
row1.Cells[0].Style = style;
}
_gridSources.Rows.Add(row1);
}
_gridSources[1, 0].Selected = true; // Выбрать невидимую строку, чтобы убрать выделение по умолчанию с грида.
_gridSources.ClearSelection();
}
private static void StartDummyApplication(IServer server)
{
server.Start(new DummyApplication(context => TaskUtilities.CompletedTask));
}
/// <summary>
/// Creates a new <see cref="ServerClient"/> instance.
/// </summary>
/// <param name="acceptedSocket">Net User socket</param>
protected ServerClient(IServer server, Socket acceptedSocket)
: base(acceptedSocket)
{
this.Server = server;
this.RemoteEndPoint = acceptedSocket.RemoteEndPoint.ToString();
}
public SchedulerViewModel(IEventAggregator eventPublisher, DirectoryObjectPickerDialog directoryObjectPicker, IPopupController popupController, IAsyncWorker asyncWorker, IServer server, Func <IServer, IServer> toEnvironmentModel)
: this(eventPublisher, directoryObjectPicker, popupController, asyncWorker, server, toEnvironmentModel, null)
{
}
public void NewServerSourceCommand(string resourcePath, IServer server)
{
SetActiveStates(_shellViewModel, server);
_shellViewModel.NewServerSource(resourcePath);
}
static void SetActiveStates(IShellViewModel shellViewModel, IServer server)
{
shellViewModel.SetActiveServer(server.EnvironmentID);
}
/// <summary>
/// Complete constructor
/// </summary>
/// <param name="c">Client reference</param>
/// <param name="s">Server reference</param>
/// <param name="txt">Text to parse and optional parameters separated by semicolon</param>
/// <param name="prev">Link to caller screen</param>
public SelectLocale(IBBSClient c, IServer s, string txt, IScreen prev) : base(c, s, txt, prev)
{
InitCatalog();
}
public IEnumerator Run()
{
List <Shape> shapes = new List <Shape>();
float elapsedTime = 0;
int minConnectAttempts = 10;
int attempt = 0;
int validationCount = 0;
//--------------------------------------------------------
// Initialise the server.
IServer server = InitialiseServer();
Debug.Log("Server initialised.");
server.ConnectionMonitor.Start(ConnectionMonitorMode.Synchronous);
yield return(null);
//--------------------------------------------------------
// Connect sever.
_tes.Connect(new IPEndPoint(IPAddress.Loopback, TestPort), true);
Debug.Log("Connecting...");
elapsedTime = 0;
attempt = 0;
bool connected = false;
do
{
server.ConnectionMonitor.MonitorConnections();
server.ConnectionMonitor.CommitConnections(null);
yield return(null);
elapsedTime += Time.deltaTime;
connected = _tes.Connected && server.ConnectionCount > 0;
} while (!connected && (elapsedTime < ConnectWaitTime || attempt++ < minConnectAttempts));
Debug.Assert(_tes.Connected);
Debug.Assert(server.ConnectionCount > 0);
Debug.Log("Connected");
//--------------------------------------------------------
// Create scene.
if (!CreateShapes(server, shapes))
{
Debug.LogError("Shape creation failed.");
Debug.Assert(false);
yield break;
}
Debug.Assert(server.UpdateTransfers(0) >= 0);
Debug.Assert(server.UpdateFrame(Time.deltaTime) >= 0);
Debug.Log("Shapes created.");
yield return(null);
// Delay a frame to ensure data propagation (in case we have script execution order issues).
Debug.Assert(server.UpdateFrame(Time.deltaTime) >= 0);;
Debug.Log("Delayed");
yield return(null);
//--------------------------------------------------------
// Validate client scene.
++validationCount;
if (!ValidateScene(shapes))
{
Debug.LogError(string.Format("Scene validation {0} failed.", validationCount));
Debug.Assert(false);
yield break;
}
yield return(null);
//--------------------------------------------------------
// Serialise client scene file in the Unity Temp directory.
string sceneFile1 = Path.GetFullPath(Path.Combine("Temp", "test-scene01.3es"));
string sceneFile2 = Path.GetFullPath(Path.Combine("Temp", "test-scene02.3es"));
// Note: compression is very slow in debug builds.
// TODO: re-enable compression. The GZipStream we use seems to generate incomplete streams on larger streams
// possibly due to usage issues here.
// Debug.Assert(_tes.SerialiseScene(sceneFile1, true));
Debug.Assert(_tes.SerialiseScene(sceneFile1, false));
Debug.Log("Serialised scene");
yield return(null);
//--------------------------------------------------------
// Disconnect.
_tes.Disconnect();
// Wait for disconnect.
yield return(new WaitForSeconds(0.5f));
// server.ConnectionMonitor.MonitorConnections();
// server.ConnectionMonitor.CommitConnections(null);
// Debug.Log($"connections: {server.ConnectionCount}");
// Debug.Assert(server.ConnectionCount == 0);
//server.Destroy();
server.ConnectionMonitor.Stop();
server = null;
Debug.Log("Disconnected");
yield return(null);
//--------------------------------------------------------
// Reset and load the scene.
Debug.Assert(_tes.OpenFile(sceneFile1));
Debug.Log("Restored scene 1");
yield return(null);
// Give the stream thread a chance to read.
yield return(new WaitForSeconds(StreamWaitTime));
//--------------------------------------------------------
// Validate client scene.
++validationCount;
if (!ValidateScene(shapes))
{
Debug.LogError(string.Format("Scene validation {0} failed.", validationCount));
Debug.Assert(false);
yield break;
}
yield return(null);
//--------------------------------------------------------
// Serialise again.
// TODO: push a keyframe message instead and validate against that.
Debug.Assert(_tes.SerialiseScene(sceneFile2, false));
Debug.Log("Serialised scene again");
yield return(null);
//--------------------------------------------------------
// Reset and load the scene.
Debug.Assert(_tes.OpenFile(sceneFile2));
Debug.Log("Restored scene 2");
yield return(null);
// Give the stream thread a chance to read.
yield return(new WaitForSeconds(StreamWaitTime));
//--------------------------------------------------------
// Validate client scene.
++validationCount;
if (!ValidateScene(shapes))
{
Debug.LogError(string.Format("Scene validation {0} failed.", validationCount));
Debug.Assert(false);
yield break;
}
yield return(null);
Debug.Log("Test OK");
}
bool CreateShapes(IServer server, List <Shape> shapes)
{
try
{
// Explicit instantiation for:
// - MeshShape
// - MeshSet
// - PointCloudShape
// - Text2D
// - Text3D
// ( Categories)
Type[] explicitTypes = new Type[]
{
typeof(MeshShape),
typeof(MeshSet),
typeof(PointCloudShape),
typeof(Text2D),
typeof(Text3D)
};
ConstructorInfo[] simpleConstructors = GenerateShapeConstructors(explicitTypes);
Shape shape = null;
ShapeDelegate postCreate = null;
uint objId = 0;
foreach (ConstructorInfo constructor in simpleConstructors)
{
object obj = constructor.Invoke(new object[] { ++objId, (ushort)0 });
shape = (Shape)obj;// constructor.Invoke(new object[] { ++objId, (ushort)0 });
shape.Position = new Tes.Maths.Vector3((float)objId);
shape.Rotation = Tes.Maths.Quaternion.AxisAngle(new Tes.Maths.Vector3(1, 1, 0).Normalised, (objId * 24.0f) / 180.0f * Mathf.PI);
shape.Scale = new Tes.Maths.Vector3(0.5f, 0.1f, 0.1f);
shape.Colour = Tes.Maths.Colour.Cycle(objId).Value;
if (_postCreationFunctions.TryGetValue(shape.GetType(), out postCreate))
{
postCreate(shape);
}
server.Create(shape);
shapes.Add(shape);
}
// Now make explicit instantiations.
// Tessellate a sphere for mesh tests.
List <Vector3> verts = new List <Vector3>();
List <Vector3> normals = new List <Vector3>();
List <int> indices = new List <int>();
Tes.Tessellate.Sphere.SubdivisionSphere(verts, normals, indices, Vector3.zero, 0.42f, 5);
shape = CreateMesh(++objId, verts, normals, indices);
shape.Position = new Tes.Maths.Vector3((float)objId);
server.Create(shape);
shapes.Add(shape);
_sampleMesh = CreateMeshResource(1u, verts, normals, indices);
shape = CreateMeshSet(++objId, _sampleMesh);
server.Create(shape);
shapes.Add(shape);
shape = CreateCloud(++objId, _sampleMesh);
server.Create(shape);
shapes.Add(shape);
shape = CreateText2D(++objId);
server.Create(shape);
shapes.Add(shape);
shape = CreateText3D(++objId);
server.Create(shape);
shapes.Add(shape);
}
catch (Exception e)
{
Debug.LogException(e);
return(false);
}
return(true);
}
public ManageWcfSourceViewModel(IWcfSourceModel updateManager, IEventAggregator aggregator, IWcfServerSource wcfSource, IAsyncWorker asyncWorker, IServer environment)
: this(updateManager, aggregator, asyncWorker, environment)
{
VerifyArgument.IsNotNull("source", wcfSource);
asyncWorker.Start(() => updateManager.FetchSource(wcfSource.Id), source =>
{
_wcfServerSource = source;
_wcfServerSource.Path = wcfSource.Path;
SetupHeaderTextFromExisting();
FromModel(source);
});
}
public ManageWcfSourceViewModel(IWcfSourceModel updateManager, IEventAggregator aggregator, IAsyncWorker asyncWorker, IServer environment)
: base("WcfSource")
{
VerifyArgument.IsNotNull("asyncWorker", asyncWorker);
VerifyArgument.IsNotNull("updateManager", updateManager);
VerifyArgument.IsNotNull("aggregator", aggregator);
AsyncWorker = asyncWorker;
_environment = environment;
_updateManager = updateManager;
_endPointUrl = string.Empty;
HeaderText = Resources.Languages.Core.WcfServiceNewHeaderLabel;
Header = Resources.Languages.Core.WcfServiceNewHeaderLabel;
TestCommand = new Microsoft.Practices.Prism.Commands.DelegateCommand(TestConnection, CanTest);
SaveCommand = new Microsoft.Practices.Prism.Commands.DelegateCommand(SaveConnection, CanSave);
CancelTestCommand = new Microsoft.Practices.Prism.Commands.DelegateCommand(CancelTest, CanCancelTest);
}
private void Form1_Load(object sender, EventArgs e)
{
WellKnownClientTypeEntry[] tps = RemotingConfiguration.GetRegisteredWellKnownClientTypes();
srv = (IServer)Activator.GetObject(typeof(IServer), tps[0].ObjectUrl);
}
public ManageWcfSourceViewModel(IWcfSourceModel updateManager, Task <IRequestServiceNameViewModel> requestServiceNameViewModel, IEventAggregator aggregator, IAsyncWorker asyncWorker, IServer environment)
: this(updateManager, aggregator, asyncWorker, environment)
{
VerifyArgument.IsNotNull("requestServiceNameViewModel", requestServiceNameViewModel);
_requestServiceNameViewModel = requestServiceNameViewModel;
}
public ToucheePluginContext(IServer server)
{
this.Server = server;
}
public RedisCacheManager(AppSettings appSettings)
{
_server = ConnectionMultiplexer.Connect($"{appSettings.RedisConnectionString},allowAdmin=true").GetServer(appSettings.RedisConnectionString);
_db = ConnectionMultiplexer.Connect(appSettings.RedisConnectionString).GetDatabase();
}
/// <summary>
/// Method called to load the plugin
/// </summary>
/// <param name="server">Server in which the plugin will be loaded</param>
public void Startup(IServer server)
{
}
private static string?GetServerId(IServer server)
{
return(server?.ClusterConfiguration?[server.EndPoint]?.NodeId);
}
