public static string GetFileOrFolderBasedUserFriendlyConnectionName(IConnectionParams cp) { string displayName = cp[ConnectionParamsKeys.DisplayNameConnectionParam]; if (!string.IsNullOrEmpty(displayName)) { return(displayName); } string rotatedLogFolder = cp[ConnectionParamsKeys.RotatedLogFolderPathConnectionParam]; if (!string.IsNullOrEmpty(rotatedLogFolder)) { var patterns = string.Join(";", GetRotatedLogPatterns(cp)); if (patterns != "") { patterns = $" ({patterns})"; } return(rotatedLogFolder + patterns); } string id = cp[ConnectionParamsKeys.IdentityConnectionParam]; if (!string.IsNullOrEmpty(id)) { return(id); } return(cp[ConnectionParamsKeys.PathConnectionParam] ?? ""); }
IConnectionParams ILogProviderFactory.GetConnectionParamsToBeStoredInMRUList(IConnectionParams originalConnectionParams) { var ret = new ConnectionParams(); ret[ConnectionParamsUtils.IdentityConnectionParam] = connectionIdentity; return(ret); }
private async void ReadAll( ILogProviderFactory factory, IConnectionParams connectParams) { try { provider = factory.CreateFromConnectionParams(this, connectParams); var messages = new List <IMessage>(); await this.provider.EnumMessages( 0, m => { messages.Add(m); return(true); }, EnumMessagesFlag.Forward, LogProviderCommandPriority.RealtimeUserAction, CancellationToken.None ); model.SetMessages(messages); await logPresenter.GoHome(); UpdateStatusControls(messages.Count, null); } catch (Exception e) { UpdateStatusControls(0, e); } }
public LogSource(ILogSourcesManagerInternal owner, int id, ILogProviderFactory providerFactory, IConnectionParams connectionParams, IModelThreads threads, ITempFilesManager tempFilesManager, Persistence.IStorageManager storageManager, IInvokeSynchronization invoker, Settings.IGlobalSettingsAccessor globalSettingsAccess, IBookmarks bookmarks) { this.owner = owner; this.tracer = new LJTraceSource("LogSource", string.Format("ls{0:D2}", id)); this.tempFilesManager = tempFilesManager; this.invoker = invoker; this.globalSettingsAccess = globalSettingsAccess; this.bookmarks = bookmarks; try { this.logSourceThreads = new LogSourceThreads(this.tracer, threads, this); this.timeGaps = new TimeGapsDetector(tracer, invoker, new LogSourceGapsSource(this)); this.timeGaps.OnTimeGapsChanged += timeGaps_OnTimeGapsChanged; this.logSourceSpecificStorageEntry = CreateLogSourceSpecificStorageEntry(providerFactory, connectionParams, storageManager); var extendedConnectionParams = connectionParams.Clone(true); this.LoadPersistedSettings(extendedConnectionParams); this.provider = providerFactory.CreateFromConnectionParams(this, extendedConnectionParams); } catch (Exception e) { tracer.Error(e, "Failed to initialize log source"); ((ILogSource)this).Dispose(); throw; } this.owner.Container.Add(this); this.owner.FireOnLogSourceAdded(this); this.LoadBookmarks(); }
public SimpleFileMedia(IFileSystem fileSystem, IConnectionParams connectParams) { if (fileSystem == null) { throw new ArgumentNullException("fileSystem"); } this.fileSystem = fileSystem; this.fileName = connectParams[fileNameParam]; if (string.IsNullOrEmpty(fileName)) { throw new ArgumentException("Invalid or incomplete connection params"); } try { Stream fs = fileSystem.OpenFile(fileName); this.stream.SetStream(fs, true); this.fsInfo = (IFileStreamInfo)fs; Update(); } catch (Exception) { Dispose(); throw; } }
static IEnumerable <LoadedPreprocessingStep> LoadStepsFromConnectionParams(IConnectionParams connectParams) { for (int stepIdx = 0; ; ++stepIdx) { string stepStr = connectParams[string.Format("{0}{1}", ConnectionParamsUtils.PreprocessingStepParamPrefix, stepIdx)]; if (stepStr == null) { break; } stepStr = stepStr.Trim(); if (stepStr.Length == 0) { break; } int idx = stepStr.IndexOf(' '); if (idx == -1) { yield return(new LoadedPreprocessingStep(stepStr, "")); } else { yield return(new LoadedPreprocessingStep(stepStr.Substring(0, idx), stepStr.Substring(idx + 1))); } } }
/// <summary> /// Отправить устройству параметры для подключения к роутеру /// </summary> /// <param name="connectionParams"></param> /// <returns></returns> public async Task <bool> SendConnectionParamsToDeviceAsAP(IConnectionParams connectionParams) { return(await Task.Run(async() => { List <CommandParameter> content = new List <CommandParameter> { new CommandParameter("ssid", connectionParams.Ssid), new CommandParameter("password", connectionParams.Password) }; //TODO: изменить на устройстве код приёма параметров подключения Communicator communicator = new Communicator(); OperationResult result = await communicator.SendToDevice(_ip, CommandNames.ConnectionParams, content); if (!result.Success) { ConnectorByWiFi connector = new ConnectorByWiFi(); WiFiAdapter wiFiAdapter = await connector.GetWiFiAdapter(); if (wiFiAdapter.NetworkAdapter.NetworkItem.GetNetworkTypes() == Windows.Networking.Connectivity.NetworkTypes.None) { result.Success = await connector.Reconnect(); } } return result.Success; })); }
internal MSSQLConnection(IConnectionParams @params, bool connect = true) : this() { if (connect) { Connect(@params); } }
string IManager.ExtractUserBrowsableFileLocationFromConnectionParams(IConnectionParams connectParams) { var steps = LoadStepsFromConnectionParams(connectParams).ToArray(); var stepObjects = steps.Select(s => CreateStepByName(s.StepName, null)); var getStep = stepObjects.FirstOrDefault() as IGetPreprocessingStep; string fileName = null; if (getStep != null) { var secondStep = stepObjects.Skip(1).FirstOrDefault(); if (secondStep == null || secondStep is IUnpackPreprocessingStep) { fileName = steps[0].Argument; } } else { fileName = connectParams[ConnectionParamsKeys.PathConnectionParam]; } if (!string.IsNullOrEmpty(fileName) && !tempFilesManager.IsTemporaryFile(fileName)) { return(fileName); } return(null); }
public static void ValidateConnectionParams(IConnectionParams cp, ILogProviderFactory againstFactory) { if (GetConnectionIdentity(cp) == null) { throw new InvalidConnectionParamsException("no connection identity in connectino params"); } }
public LogProvider(ILogProviderHost host, IConnectionParams connectParams, ILogProviderFactory factory) : base(host, factory, connectParams) { this.fileName = connectParams[ConnectionParamsKeys.PathConnectionParam]; StartLiveLogThread(string.Format("'{0}' listening thread", fileName)); }
public AzureConnectionParams(IConnectionParams connectParams) { Account = new StorageAccount(connectParams); var fmtProv = CultureInfo.InvariantCulture.DateTimeFormat; Func <string, DateTime> parseDate = str => DateTime.ParseExact(str, ConnectionParamsConsts.DateConnectionParamFormat, fmtProv); Func <string, TimeSpan> parseTimeSpan = str => TimeSpan.ParseExact(str, ConnectionParamsConsts.TimespanConnectionParamFormat, fmtProv); var fromStr = connectParams[ConnectionParamsConsts.FromConnectionParam]; var tillStr = connectParams[ConnectionParamsConsts.TillConnectionParam]; var periodStr = connectParams[ConnectionParamsConsts.RecentConnectionParam]; var liveStr = connectParams[ConnectionParamsConsts.LiveConnectionParam]; if (fromStr != null) { Mode = LoadMode.FixedRange; From = parseDate(fromStr); Till = parseDate(tillStr); } else if (periodStr != null) { Mode = LoadMode.Recent; Period = parseTimeSpan(periodStr); bool live; bool.TryParse(connectParams[ConnectionParamsConsts.LiveConnectionParam] ?? "", out live); Live = live; } else { throw new InvalidConnectionParamsException("Bad connection params for Azure log provider"); } }
void ApplyRotatedLogMode() { var folder = ((string)view.ReadControlValue(ControlId.FolderSelector)).Trim(); if (folder == "") { return; } if (!System.IO.Directory.Exists(folder)) { alerts.ShowPopup("Error", "Specified folder does not exist", AlertFlags.Ok | AlertFlags.WarningIcon); return; } view.WriteControlValue(ControlId.FolderSelector, ""); folder = folder.TrimEnd('\\'); IConnectionParams connectParams = factory.CreateRotatedLogParams(folder); try { model.Create(factory, connectParams); } catch (Exception e) { alerts.ShowPopup("Error", e.Message, AlertFlags.Ok | AlertFlags.WarningIcon); } }
void InitPathDependentMembers(IConnectionParams connectParams) { isSavableAs = false; taskbarFileName = null; bool isTempFile = false; string guessedFileName = null; string fname = connectParams[ConnectionParamsKeys.PathConnectionParam]; if (fname != null) { isTempFile = host.TempFilesManager.IsTemporaryFile(fname); isSavableAs = isTempFile; } string connectionIdentity = connectParams[ConnectionParamsKeys.IdentityConnectionParam]; if (connectionIdentity != null) { guessedFileName = ConnectionParamsUtils.GuessFileNameFromConnectionIdentity(connectionIdentity); } if (isSavableAs) { suggestedSaveAsFileName = SanitizeSuggestedFileName(guessedFileName); } taskbarFileName = guessedFileName; }
void ApplyRotatedLogMode() { var folder = ((string)view.ReadControlValue(ControlId.FolderSelector)).Trim(); if (folder == "") { return; } if (!System.IO.Directory.Exists(folder)) { alerts.ShowPopup("Error", "Specified folder does not exist", AlertFlags.Ok | AlertFlags.WarningIcon); return; } view.WriteControlValue(ControlId.FolderSelector, ""); folder = folder.TrimEnd(System.IO.Path.DirectorySeparatorChar); var patters = (string)view.ReadControlValue(ControlId.PatternsSelector); IConnectionParams connectParams = factory.CreateRotatedLogParams(folder, patters.Split(';').Where(s => !string.IsNullOrWhiteSpace(s))); try { model.Create(factory, connectParams); } catch (Exception e) { alerts.ShowPopup("Error", e.Message, AlertFlags.Ok | AlertFlags.WarningIcon); } }
public IConnectionParams GetConnectionParamsToBeStoredInMRUList(IConnectionParams originalConnectionParams) { var ret = new ConnectionParams(); ret[ConnectionParamsUtils.IdentityConnectionParam] = connectionIdentity; return(ret); }
public YieldedProvider(ILogProviderFactory factory, IConnectionParams connectionParams, string displayName, bool isHiddenLog) { Factory = factory; ConnectionParams = connectionParams; DisplayName = displayName; IsHiddenLog = isHiddenLog; }
bool IPresenter.ShowDialog(ILogProviderFactory sampleLogFactory, IConnectionParams sampleLogConnectionParams) { ReadAll(sampleLogFactory, sampleLogConnectionParams); view.Show(); return(statusOk); }
IConnectionParams IManager.AppendStep( IConnectionParams connectParams, string stepName, string stepArgument) { var steps = LoadStepsFromConnectionParams(connectParams).ToList(); if (steps.Count == 0) { var path = connectParams[ConnectionParamsKeys.PathConnectionParam]; if (path == null) { return(null); } steps.Add(new PreprocessingHistoryItem(GetPreprocessingStep.name, path)); } steps.Add(new PreprocessingHistoryItem(stepName, stepArgument)); var retVal = connectParams.Clone(makeWritebleCopyIfReadonly: true); int stepIdx = 0; foreach (var step in steps) { retVal[string.Format("{0}{1}", ConnectionParamsKeys.PreprocessingStepParamPrefix, stepIdx)] = string.Format(string.IsNullOrEmpty(step.Argument) ? "{0}" : "{0} {1}", step.StepName, step.Argument); ++stepIdx; } return(retVal); }
public ConnectionParamsReadOnlyView(IConnectionParams underlyingParams) { if (underlyingParams == null) { throw new ArgumentNullException("underlyingParams"); } this.underlyingParams = underlyingParams; }
public static IConnectionParams RemoveInitialTimeOffset(IConnectionParams cp) { if (!string.IsNullOrEmpty(cp[TimeOffsetConnectionParam])) { cp[TimeOffsetConnectionParam] = null; } return(cp); }
readonly long defaultBackupMaxFileSize = 0; //16 * 1024 * 1024; static ConnectionParams CreateConnectionParams(IConnectionParams originalConnectionParams, ITempFilesManager tempFilesManager) { ConnectionParams connectParams = new ConnectionParams(); connectParams.AssignFrom(originalConnectionParams); connectParams[ConnectionParamsUtils.PathConnectionParam] = tempFilesManager.CreateEmptyFile(); return(connectParams); }
ILogSource CreateLogSourceInternal(ILogProviderFactory factory, IConnectionParams cp, bool makeHidden) { ILogSource src = logSources.FindLiveLogSourceOrCreateNew(factory, cp); src.Visible = !makeHidden; mruLogsList.RegisterRecentLogEntry(src.Provider, src.Annotation); return(src); }
IConnectionParams ILogProviderFactory.GetConnectionParamsToBeStoredInMRUList(IConnectionParams originalConnectionParams) { var cp = originalConnectionParams.Clone(true); cp[ConnectionParamsKeys.PathConnectionParam] = null; ConnectionParamsUtils.RemoveInitialTimeOffset(cp); return(cp); }
private SimpleFileMedia(IFileSystem fileSystem, IConnectionParams connectParams) { this.fileSystem = fileSystem ?? throw new ArgumentNullException("fileSystem"); this.fileName = connectParams[fileNameParam]; if (string.IsNullOrEmpty(fileName)) { throw new ArgumentException("Invalid or incomplete connection params"); } }
ILogSource ILogSourcesManager.Create(ILogProviderFactory providerFactory, IConnectionParams cp) { return(logSourceFactory.CreateLogSource( this, ++lastLogSourceId, providerFactory, cp )); }
public static string GetConnectionIdentity(IConnectionParams cp) { var ret = cp[IdentityConnectionParam]; if (string.IsNullOrWhiteSpace(ret)) { return(null); } return(ret); }
public bool AreEqual(IConnectionParams other) { SemicolonSeparatedMap map = other as SemicolonSeparatedMap; if (map == null) { return(false); } return(base.AreEqual(map)); }
public static bool ConnectionsHaveEqualIdentities(IConnectionParams cp1, IConnectionParams cp2) { var id1 = GetConnectionIdentity(cp1); var id2 = GetConnectionIdentity(cp2); if (id1 == null || id2 == null) { return(false); } return(id1 == id2); }
public RollingStrategy(LJTraceSource trace, IConnectionParams connectionParams) { baseFileName = connectionParams[fileNameParam]; if (string.IsNullOrEmpty(baseFileName)) { throw new ArgumentException("Base file name is not specified in the connection params"); } baseFileNameFirstChar = GetFileNameFirstChar(baseFileName); baseDirectory = Path.GetDirectoryName(baseFileName); trace.Info("Base file name first character: {0}", baseFileNameFirstChar); }