public LogWindow()
{
InitializeComponent();
_logListener = new LogListener(LogCallback);
Trace.Listeners.Add(_logListener);
}
public MainViewModel(MainWindow mainWindow)
{
CurrentSerialPort = new ViewModelProperty <string>(ConnectToArduino);
CurrentProgrammerProfile = new ViewModelProperty <string>(LoadProfile);
SerialPorts = new ViewModelProperty <IEnumerable <string> >();
ProgrammerProfiles = new ViewModelProperty <IEnumerable <string> >();
SerialPortMenuItems = new ReadOnlyViewModelProperty <List <SerialPortMenuItem> >(SerialPorts, () =>
{
var items = new List <SerialPortMenuItem>();
if (SerialPorts.Value != null)
{
foreach (var item in SerialPorts.Value)
{
items.Add(new SerialPortSelectionItem(this, item));
}
}
if (items.Count == 0)
{
items.Add(NoPortsAvailable.Value);
}
return(items);
});
SerialMonitor = new SerialMonitor();
TestButtonDeckCommand = new ActionCommandModel(() => !string.IsNullOrEmpty(CurrentSerialPort.Value), OnTestButtonDeck);
LoggingCommand = new ActionCommandModel(() => true, OnOpenLogging);
OpenProgrammer = new ActionCommandModel(() => true, OnOpenProgrammer);
LogListener = new LogListener();
RootLogger = new LoggerFactory().Create(LogListener);
Communication = new ButtonDeckCommunication(RootLogger);
MainWindow = mainWindow;
}
public BungieClient(Action <BungieClientSettings> configure)
{
BungieClientSettings settings = new BungieClientSettings();
configure(settings);
Configuration = StaticUnityContainer.GetConfiguration();
if (settings.UseExistingConfig)
{
Configuration.ApplySettingsFromConfig(settings.ExistingConfigPath);
}
else
{
Configuration.ApplySettings(settings);
}
_logger = StaticUnityContainer.GetLogger();
if (Configuration.Settings.IsLoggingEnabled)
{
LogListener = new LogListener();
_logger.Register(LogListener);
}
CDN = new BungieCDNClient();
Platform = new BungiePlatfromClient(Configuration.Settings.ApiKey, Configuration);
_versionControl = StaticUnityContainer.GetManifestUpdateHandler();
}
/// <summary>
/// Initializes a new instance of the <see cref="Game"/> class.
/// </summary>
public Game()
{
// Register the logger backend before anything else
logListener = GetLogListener();
if (logListener != null)
{
GlobalLogger.GlobalMessageLogged += logListener;
}
// Create all core services, except Input which is created during `Initialize'.
// Registration takes place in `Initialize'.
Script = new ScriptSystem(Services);
SceneSystem = new SceneSystem(Services);
Audio = new AudioSystem(Services);
gameFontSystem = new GameFontSystem(Services);
SpriteAnimation = new SpriteAnimationSystem(Services);
DebugConsoleSystem = new DebugConsoleSystem(Services);
ProfilerSystem = new GameProfilingSystem(Services);
Content.Serializer.LowLevelSerializerSelector = ParameterContainerExtensions.DefaultSceneSerializerSelector;
// Creates the graphics device manager
GraphicsDeviceManager = new GraphicsDeviceManager(this);
AutoLoadDefaultSettings = true;
}
public void removeListener(LogListener listener)
{
OgrePINVOKE.Log_removeListener(swigCPtr, LogListener.getCPtr(listener));
if (OgrePINVOKE.SWIGPendingException.Pending)
{
throw OgrePINVOKE.SWIGPendingException.Retrieve();
}
}
protected void Init(string phaseName)
{
Listener = new LogListener(phaseName)
{
LogLevelThreshold = LogLevel.Warning
};
Logger.RegisterListener(Listener);
}
public void setLogListener(LogListener logListener)
{
this.logListener = logListener;
if (canReceivePush && gcm != null && loggingEnabled)
{
gcm.SetLogListener(logListener);
}
}
public MainWindow()
{
InitializeComponent();
mainViewModel = new MainViewModel();
DataContext = mainViewModel;
listenTask = Task.Run(() => LogListener.Listen());
dataGrid.Loaded += HandleDataGridLoaded;
Closing += HandleClosing;
}
/// <summary>
/// Create new log parameters.
/// </summary>
/// <param name="sender">The object that raised the event.</param>
/// <param name="e">Event arguments.</param>
private void NewLogParameters(object sender, EventArgs e)
{
try
{
LogListenerManagerWindow dlg = sender as LogListenerManagerWindow;
if (App.Instance.SalesForceApp.CurrentProject != null && dlg != null)
{
NewLogParametersWindow newDlg = new NewLogParametersWindow();
newDlg.Title = "New Log Listener";
newDlg.SaveButtonText = "Create";
newDlg.TracedEntity = App.Instance.SalesForceApp.CurrentProject.Client.User;
newDlg.Scope = String.Empty;
newDlg.ExpirationDate = DateTime.Now.AddDays(1);
newDlg.LogLevelCode = LogLevel.Info;
newDlg.LogLevelProfiling = LogLevel.Info;
newDlg.LogLevelDatabase = LogLevel.Info;
newDlg.UserSearch += UserSearch;
try
{
if (App.ShowDialog(newDlg))
{
using (App.Wait("Creating Log Listener"))
{
LogListener log = App.Instance.SalesForceApp.CurrentProject.Client.Diagnostic.CreateLogListener(
(newDlg.TracedEntity as User).Id,
String.Format("{0} (user)", newDlg.TracedEntity),
String.Empty,
String.Empty,
(newDlg.ExpirationDate.HasValue) ? newDlg.ExpirationDate.Value : DateTime.Now.AddHours(4),
newDlg.LogLevelCode,
newDlg.LogLevelVisualForce,
newDlg.LogLevelProfiling,
newDlg.LogLevelCallout,
newDlg.LogLevelDatabase,
newDlg.LogLevelSystem,
newDlg.LogLevelValidation,
newDlg.LogLevelWorkflow);
List <LogListener> list = new List <LogListener>(dlg.LogParameters);
list.Add(log);
dlg.LogParameters = list;
}
}
}
finally
{
newDlg.UserSearch -= UserSearch;
}
}
}
catch (Exception err)
{
App.HandleException(err);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Game"/> class.
/// </summary>
public Game()
{
// Register the logger backend before anything else
logListener = GetLogListener();
if (logListener != null)
{
GlobalLogger.GlobalMessageLogged += logListener;
}
// Create and register all core services
Input = new InputManager(Services);
Script = new ScriptSystem(Services);
SceneSystem = new SceneSystem(Services);
Audio = new AudioSystem(Services);
UI = new UISystem(Services);
gameFontSystem = new GameFontSystem(Services);
SpriteAnimation = new SpriteAnimationSystem(Services);
ProfilerSystem = new GameProfilingSystem(Services);
// ---------------------------------------------------------
// Add common GameSystems - Adding order is important
// (Unless overriden by gameSystem.UpdateOrder)
// ---------------------------------------------------------
// Add the input manager
GameSystems.Add(Input);
// Add the scheduler system
// - Must be after Input, so that scripts are able to get latest input
// - Must be before Entities/Camera/Audio/UI, so that scripts can apply
// changes in the same frame they will be applied
GameSystems.Add(Script);
// Add the UI System
GameSystems.Add(UI);
// Add the Audio System
GameSystems.Add(Audio);
// Add the Font system
GameSystems.Add(gameFontSystem);
//Add the sprite animation System
GameSystems.Add(SpriteAnimation);
Asset.Serializer.LowLevelSerializerSelector = ParameterContainerExtensions.DefaultSceneSerializerSelector;
// Creates the graphics device manager
GraphicsDeviceManager = new GraphicsDeviceManager(this);
GameSystems.Add(ProfilerSystem);
AutoLoadDefaultSettings = true;
}
/// <summary>
/// If this document represents the given entity this method should return true.
/// </summary>
/// <param name="entity">The entity to check.</param>
/// <returns>true if this document represents the given entity.</returns>
public override bool RepresentsEntity(object entity)
{
LogListener otherParameters = entity as LogListener;
if (otherParameters == null)
{
return(false);
}
return(Parameters.TracedEntityId == otherParameters.TracedEntityId);
}
static void Main()
{
var myDocumentsPath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
var logFile = Path.Combine(myDocumentsPath, "iRacingDirector.Plugin.Tester.log");
LogListener.ToFile(logFile);
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.ThreadException += Application_ThreadException;
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
Application.Run(new Main());
}
void BeginProcessButton_Click(object sender, EventArgs e)
{
BeginProcessButton.Enabled = false;
AnalysingRaceLabel.Visible = true;
State = States.CapturingGameData;
LogListener.ToFile(workingFolderTextBox.Text + "\\capture.log");
AwsLogListener.SetPhaseCapture();
NativeMethods.SetThreadExecutionState(NativeMethods.ES_CONTINUOUS | NativeMethods.ES_SYSTEM_REQUIRED | NativeMethods.ES_DISPLAY_REQUIRED);
iRacingProcess = new IRacingReplay(shortTestOnly: TestOnlyCheckBox.Checked)
.WithWorkingFolder(workingFolderTextBox.Text)
.AnalyseRace(() => { AnalysingRaceLabel.Visible = false; CapturingRaceLabel.Visible = true; })
.CaptureOpeningScenes()
.CaptureRace(overlayFileName =>
{
sourceVideoTextBox.Text = overlayFileName;
LogListener.MoveToFile(Path.ChangeExtension(overlayFileName, "log"));
})
.CloseIRacing()
.InTheBackground(errorMessage =>
{
workingFolderTextBox_TextChanged(null, null);
WaitingForIRacingLabel.Visible = false;
AnalysingRaceLabel.Visible = false;
CapturingRaceLabel.Visible = false;
ProcessErrorMessageLabel.Visible = true;
ProcessErrorMessageLabel.Text = errorMessage;
State = States.Idle;
StateUpdated();
LogListener.ToFile(GetDefaultLogFileName());
AwsLogListener.SetPhaseGeneral();
WindowState = FormWindowState.Minimized;
Show();
WindowState = FormWindowState.Normal;
this.BringToFront();
if (errorMessage == null && transcodeVideoButton.Enabled && EncodeVideoAfterCapture.Checked)
{
tabControl1.SelectedIndex = 1;
Thread.Sleep(1000);
TranscodeVideo_Click(null, null);
}
else
{
NativeMethods.SetThreadExecutionState(NativeMethods.ES_CONTINUOUS);
}
});
}
private IAppender GetAppender(LogListener listener, LoggerConfiguration confguration)
{
switch (listener.Type)
{
case "textFile":
return(GetFileAppender(listener));
case "console":
return(GetConsoleAppender(listener));
default:
return(GetCustomAppender(listener, confguration));
}
}
private IAppender GetConsoleAppender(LogListener listener)
{
var appender = new ConsoleAppender();
var patternLayout = new PatternLayout {
ConversionPattern = DeafultPatternLayout
};
patternLayout.ActivateOptions();
appender.Layout = patternLayout;
appender.AddFilter(new LevelRangeFilter {
LevelMin = _levelMap[listener.MinLevel], LevelMax = _levelMap[listener.MaxLevel]
});
return(appender);
}
/// <summary>
/// Initializes a new instance of the <see cref="Game"/> class.
/// </summary>
public Game()
{
// Register the logger backend before anything else
logListener = GetLogListener();
if (logListener != null)
{
GlobalLogger.GlobalMessageLogged += logListener;
}
// Create all core services, except Input which is created during `Initialize'.
// Registration takes place in `Initialize'.
Script = new ScriptSystem(Services);
Services.AddService(Script);
SceneSystem = new SceneSystem(Services);
Services.AddService(SceneSystem);
Streaming = new StreamingManager(Services);
Audio = new AudioSystem(Services);
Services.AddService(Audio);
Services.AddService <IAudioEngineProvider>(Audio);
gameFontSystem = new GameFontSystem(Services);
Services.AddService(gameFontSystem.FontSystem);
Services.AddService <IFontFactory>(gameFontSystem.FontSystem);
SpriteAnimation = new SpriteAnimationSystem(Services);
Services.AddService(SpriteAnimation);
DebugTextSystem = new DebugTextSystem(Services);
Services.AddService(DebugTextSystem);
DebugRenderSystem = new DebugRenderSystem(Services);
Services.AddService(DebugRenderSystem);
ProfilingSystem = new GameProfilingSystem(Services);
Services.AddService(ProfilingSystem);
VRDeviceSystem = new VRDeviceSystem(Services);
Services.AddService(VRDeviceSystem);
// Creates the graphics device manager
GraphicsDeviceManager = new GraphicsDeviceManager(this);
Services.AddService <IGraphicsDeviceManager>(GraphicsDeviceManager);
Services.AddService <IGraphicsDeviceService>(GraphicsDeviceManager);
AutoLoadDefaultSettings = true;
}
private void HandleClosing(object sender, CancelEventArgs e)
{
mainViewModel.Save();
LogListener.Stop();
if (!LogListener.StoppedEvent.Wait(TimeSpan.FromSeconds(2)))
{
MessageBox.Show(this, "The listener didn't report having stopped. Please check the process has fully exited.",
"LogReceiver", MessageBoxButton.OK, MessageBoxImage.Warning);
}
else
{
Debug.WriteLine("The listener reported stopped.");
}
}
private static void Main(string[] args)
{
var options = new ServerOptions
{
DispatcherPort = Settings.Default.DispatcherPort,
EndpointHostname = Settings.Default.EndpointHostname,
EndpointPort = Settings.Default.EndpointPort,
LogPort = Settings.Default.LogPort,
AppPort = Settings.Default.AppPort,
ClientPort = Settings.Default.ClientPort
};
LogListener logHost = new LogListener(options.LogPort, options.ClientPort);
ApiSelfHost apiHost = new ApiSelfHost(options);
AppSelfHost appHost = new AppSelfHost(options);
JobScheduler jobScheduler = new JobScheduler();
apiHost.Start();
appHost.Start();
logHost.Start();
jobScheduler.Start();
FixDebugListeners();
string infoText = GetInfoText(options);
bool listen = true;
while (listen)
{
Console.Clear();
Console.Write(infoText);
foreach (var connection in logHost.GetConnectionList())
{
string connectionState = connection.Connected ? "connected" : "disconnected";
Console.WriteLine("#{0} {1} {2} {3} {4}",
connection.Id,
connection.ClientId,
connection.ClientName,
connection.ClientComputerName,
connectionState);
}
if (Console.KeyAvailable && Console.ReadKey(true).Key == ConsoleKey.Escape)
{
listen = false;
}
Thread.Sleep(100);
}
jobScheduler.Stop();
logHost.Stop();
appHost.Stop();
apiHost.Stop();
}
/// <summary>
/// Initializes a new instance of the <see cref="Game"/> class.
/// </summary>
public HeadlessGame()
{
// Internals
Log = GlobalLogger.GetLogger(GetType().GetTypeInfo().Name);
UpdateTime = new GameTime();
autoTickTimer = new TimerTick();
IsFixedTimeStep = true;
maximumElapsedTime = TimeSpan.FromMilliseconds(500.0);
TargetElapsedTime = TimeSpan.FromTicks(TimeSpan.TicksPerSecond / 60); // target elapsed time is by default 60Hz
// Externals
Services = new ServiceRegistry();
GraphicsDevice = GraphicsDevice.New(DeviceCreationFlags.VideoSupport, new GraphicsProfile[]
{
GraphicsProfile.Level_11_0,
GraphicsProfile.Level_11_1,
GraphicsProfile.Level_11_2
});
Services.AddService <IGraphicsDeviceService>(new GraphicsDeviceServiceLocal(GraphicsDevice));
// Database file provider
Services.AddService <IDatabaseFileProviderService>(new DatabaseFileProviderService(null));
GameSystems = new GameSystemCollection(Services);
Services.AddService <IGameSystemCollection>(GameSystems);
// Setup registry
Services.AddService <IGame>(this);
// Register the logger backend before anything else
logListener = GetLogListener();
if (logListener != null)
{
GlobalLogger.GlobalMessageLogged += logListener;
}
// Create all core services, except Input which is created during `Initialize'.
// Registration takes place in `Initialize'.
Script = new ScriptSystem(Services);
Services.AddService(Script);
SceneSystem = new SceneSystem(Services);
Services.AddService(SceneSystem);
Streaming = new StreamingManager(Services);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="parameters">Parameters.</param>
public LogViewerDocument(Project project, LogListener parameters)
{
if (project == null)
{
throw new ArgumentNullException("project");
}
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
Project = project;
View = new LogViewerControl();
View.SelectedLogChanged += View_SelectedLogChanged;
_logNodeManager = new TreeViewNodeManager(View.LogContentData);
Parameters = parameters;
}
static void Main(string[] args)
{
WebSocket socket = new WebSocket();
LogListener listener = new LogListener();
Trace.Listeners.Add(listener);
try
{
string ip = ConfigurationManager.AppSettings["serverAddress"];
int port = int.Parse(ConfigurationManager.AppSettings["serverPort"]);
socket.start(ip, port);
}
catch (Exception ex) {
Trace.TraceInformation("消息服务器启动失败！" + ex.Message);
Thread.Sleep(5);
}
}
internal BungieClient(
IConfigurationService config,
ILogger logger,
IBungieApiAccess apiAccess,
IHttpClientInstance httpClient,
IAuthorizationStateHandler authorizationHandler,
ILocalisedDestinyDefinitionRepositories repository)
{
_configuration = config;
_httpClient = httpClient;
_logger = logger;
Authentication = authorizationHandler;
Repository = repository;
ApiAccess = apiAccess;
_logListener = new LogListener();
_logger.Register(_logListener);
}
public JoystickManager()
{
joystick = null;
joystickGuid = Guid.Empty;
_listener = null;
_running = false;
_logListener = null;
_worker = new BackgroundWorker();
_worker.WorkerReportsProgress = false;
_worker.WorkerSupportsCancellation = true;
_worker.DoWork += new DoWorkEventHandler(delegate(object o, DoWorkEventArgs args) {
while (_running) {
DoPoll();
Thread.Sleep(1);
}
});
}
public Main()
{
var filename = string.Format("iRacingPitCrew-{0}.log", DateTime.Now.ToString("yyyy-MM-dd-hh-mm-ss"));
LogListener.ToFile(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), filename));
InitializeComponent();
this.toolStripMenuItem_Open.Click += toolStripMenuItem_Open_Click;
this.toolStripMenuItem_Exit.Click += toolStripMenuItem_Exit_Click;
notifyIcon.Visible = false;
if (Settings.Default.CarConfigs == null)
{
Settings.Default.CarConfigs = new CarConfigurations();
Settings.Default.Save();
}
}
private void FormDebug_FormClosing(object sender, FormClosingEventArgs e)
{
LogListener.CloseThreads();
if (WindowState == FormWindowState.Normal)
{
Config.Set(c => c.Application.WindowY, Top);
Config.Set(c => c.Application.WindowX, Left);
if (Height > 20)
{
Config.Set(c => c.Application.WindowHeight, Height);
}
if (Width > 100)
{
Config.Set(c => c.Application.WindowWidth, Width);
}
}
Config.Set(c => c.Application.Maximized, WindowState == FormWindowState.Maximized);
}
public JoystickManager()
{
joystick = null;
joystickGuid = Guid.Empty;
_listener = null;
_running = false;
_logListener = null;
_worker = new BackgroundWorker();
_worker.WorkerReportsProgress = false;
_worker.WorkerSupportsCancellation = true;
_worker.DoWork += new DoWorkEventHandler(delegate(object o, DoWorkEventArgs args) {
while (_running)
{
DoPoll();
Thread.Sleep(1);
}
});
}
private IAppender GetCustomAppender(LogListener listener, LoggerConfiguration confguration)
{
var customListener = confguration.GetCustomListener(listener.Type);
if (customListener != null)
{
var appender = new CustomAppender(customListener);
var patternLayout = new PatternLayout {
ConversionPattern = DeafultPatternLayout
};
patternLayout.ActivateOptions();
appender.Layout = patternLayout;
appender.AddFilter(new LevelRangeFilter {
LevelMin = _levelMap[listener.MinLevel], LevelMax = _levelMap[listener.MaxLevel]
});
return(appender);
}
return(null);
}
// SP Added dependency on ISyncAgent, removed start/stoprequested events in favor of direct calls to the interface methods
public MainWindowViewModel(ISyncManager syncManager,
LogListener listener,
ISyncAgent syncAgent)
{
_syncAgent = syncAgent;
_syncManager = syncManager;
_log = new LinkedList <string>();
listener.LogCreated += OnLogCreated;
_showCompleteJobs = true;
StartSyncCommand = new RelayCommand(() => StartSync());
ToggleDMTAgentCommand = new RelayCommand(() => ToggleDMTAgent());
SyncElements = GetSyncElements(_syncManager);
_syncAgent.StatusChanged += OnAgentStatusChanged;
_syncManager.JobController.NewJobStarted += OnJobStarted;
_syncManager.JobController.JobCompleted += OnJobCompleted;
}
public MasterServer(MasterServerConfiguration masterServerConfig)
{
Tracer = masterServerConfig.LogListener;
_clientManager = new ClientManager(masterServerConfig.MaxGameSessions * 4);
_sessionPool = new SessionPool(masterServerConfig.MaxGameSessions);
Tracer.PrintInfo(string.Format("Starting NetServer at Port: {0}", masterServerConfig.Port));
var parameters = new NetworkServerHandlerParameters
{
ApproveConnection = ApproveConnection,
HandleClientJoined = HandleClientJoined,
HandleClientLeft = HandleClientLeft,
HandleDataMessageReceived = HandleDataMessageReceived,
Port = masterServerConfig.Port
};
_networkServerHandler = new NetworkServerHandler(parameters);
Tracer.PrintInfo("Server started successfully.");
}
public static void RegisterListener(LogListener lw)
{
lock (listeners)
listeners.Add(lw);
if (thread == null)
{
thread = new Thread(new ThreadStart(WriteLogThread))
{
IsBackground = true,
Name = "log listener thread"
};
thread.Start();
}
foreach (var entry in history)
{
lw.Write(entry);
}
log.Info("Registered log writer: " + lw);
}
void TranscodeVideo_Click(object sender, EventArgs e)
{
State = States.Transcoding;
SetTanscodeMessage(trancodingErrorMessage: null);
LogListener.ToFile(Path.ChangeExtension(sourceVideoTextBox.Text, "log"));
AwsLogListener.SetPhaseTranscode();
NativeMethods.SetThreadExecutionState(NativeMethods.ES_CONTINUOUS | NativeMethods.ES_SYSTEM_REQUIRED);
iRacingProcess = new IRacingReplay()
.WithEncodingOf(videoBitRate: videoBitRateNumber * 1000000)
.WithOverlayFile(overlayFile: sourceVideoTextBox.Text)
.OverlayRaceDataOntoVideo(OnTranscoderProgress, OnTranscoderCompleted, highlightVideoOnly.Checked, checkBoxShutdownAfterEncode.Checked)
.InTheBackground(errorMessage => {
OnTranscoderCompleted();
SetTanscodeMessage(trancodingErrorMessage: errorMessage);
LogListener.ToFile(GetDefaultLogFileName());
AwsLogListener.SetPhaseGeneral();
NativeMethods.SetThreadExecutionState(NativeMethods.ES_CONTINUOUS);
});
}
private static void StartLog()
{
string filename = @"scout.log";
if (File.Exists(filename))
{
try
{
File.Delete(filename);
}
catch
{
}
}
System.IO.FileStream log = new System.IO.FileStream(Path.Combine(Application.StartupPath, filename), FileMode.Append);
TextWriterTraceListener listener = new LogListener(log);
Trace.Listeners.Add(listener);
Trace.AutoFlush = true;
Trace.WriteLine("-----------------------------------------------------------------");
Trace.WriteLine(String.Format("Scout started up at {0}", DateTime.Now.ToLongDateString()));
}
public void setLogListener(LogListener logListener)
{
this.logListener = logListener;
}
public void setLogListener(LogListener logListener)
{
this.logListener = logListener;
if (canReceivePush && gcm != null && loggingEnabled) {
gcm.SetLogListener(logListener);
}
}
public GCMWorker SetLogListener(LogListener logListener)
{
this.logListener = logListener;
FlushLog();
return this;
}
public void SetLogListener(LogListener listener)
{
_logListener = listener;
}
