public static bool IsUncServerRootPath(string path, [NotNullWhen(true)] out string?normalizedPath)
        {
            normalizedPath = null;

            path = path._NonNullTrim();

            path = WindowsPathParser.NormalizeDirectorySeparator(path);

            path = WindowsPathParser.RemoveLastSeparatorChar(path);

            if (path.StartsWith(@"\\"))
            {
                if (path.Length >= 3 && path[2] != '\\')
                {
                    int r = path.IndexOf(@"\", 2);
                    if (r == -1)
                    {
                        normalizedPath = path;
                        return(true);
                    }
                }
            }

            return(false);
        }
Exemplo n.º 2
0
        public static void DefaultSetDestinationsProc(LogServerReceivedData data, LogServerOptions options)
        {
            FileSystem  fs       = options.DestFileSystem;
            PathParser  parser   = fs.PathParser;
            string      root     = options.DestRootDirName;
            LogPriority priority = data.JsonData !.Priority._ParseEnum(LogPriority.None);
            LogJsonData d        = data.JsonData;

            if (d.Kind._IsSamei(LogKind.Default))
            {
                if (priority >= LogPriority.Debug)
                {
                    Add($"{d.AppName}/{d.MachineName}/Debug");
                }

                if (priority >= LogPriority.Info)
                {
                    Add($"{d.AppName}/{d.MachineName}/Info");
                }

                if (priority >= LogPriority.Error)
                {
                    Add($"{d.AppName}/{d.MachineName}/Error");
                }
            }
            else
            {
                Add($"{d.AppName}/{d.MachineName}/{d.Kind}");
            }

            void Add(string filename)
            {
                data.AddDestinationFileName(parser.NormalizeDirectorySeparator(parser.Combine(root, filename + ".log")));
            }
        }
Exemplo n.º 3
0
    public static void DefaultSetDestinationsProc(DataVaultServerReceivedData data, DataVaultServerOptions options)
    {
        FileSystem    fs     = options.DestFileSystem;
        PathParser    parser = fs.PathParser;
        string        root   = options.DestRootDirName;
        DataVaultData d      = data.JsonData !;

        string timeStampStr;

        if (d.WithTime == false)
        {
            timeStampStr = Str.DateToStrShort(d.TimeStamp.LocalDateTime.Date);
        }
        else
        {
            timeStampStr = Str.DateTimeToStrShortWithMilliSecs(d.TimeStamp.LocalDateTime);
        }

        string relativePath = Str.CombineStringArray("/", d.SystemName, d.LogName, d.KeyType, d.KeyShortValue, d.KeyFullValue,
                                                     $"{timeStampStr}-{d.SystemName}-{d.LogName}-{d.KeyType}-{d.KeyFullValue}.json");

        if (d.WriteCompleteFlag ?? false)
        {
            relativePath += ".completed";
        }

        data.AddDestinationFileName(parser.NormalizeDirectorySeparator(parser.Combine(root, relativePath)));
    }
Exemplo n.º 4
0
    public static void DefaultSetDestinationsProc(LogServerReceivedData data, LogServerOptions options)
    {
        FileSystem  fs       = options.DestFileSystem;
        PathParser  parser   = fs.PathParser;
        string      root     = options.DestRootDirName;
        LogPriority priority = data.JsonData !.Priority._ParseEnum(LogPriority.None);
        LogJsonData d        = data.JsonData;
        DateTime    date;

        if (d.TimeStamp.HasValue == false)
        {
            date = Util.ZeroDateTimeValue;
        }
        else
        {
            date = d.TimeStamp.Value.LocalDateTime.Date;
        }

        if (d.Kind._IsSamei(LogKind.Default))
        {
            if (priority >= LogPriority.Debug)
            {
                Add($"{d.AppName}/{d.MachineName}/Debug", d.AppName !, "Debug", date);
            }

            if (priority >= LogPriority.Info)
            {
                Add($"{d.AppName}/{d.MachineName}/Info", d.AppName !, "Info", date);
            }

            if (priority >= LogPriority.Error)
            {
                Add($"{d.AppName}/{d.MachineName}/Error", d.AppName !, "Error", date);
            }
        }
        else
        {
            Add($"{d.AppName}/{d.MachineName}/{d.Kind}", d.AppName !, d.Kind !, date);
        }

        void Add(string subDirName, string token0, string token1, DateTime date)
        {
            string yyyymmdd = Str.DateToStrShort(date);

            string tmp = parser.Combine(root, subDirName, $"{yyyymmdd}-{token0}-{token1}.log");

            data.AddDestinationFileName(parser.NormalizeDirectorySeparator(tmp));
        }
    }
        public DirectoryPath ConfigPathStringToPhysicalDirectoryPath(string pathString)
        {
            pathString = pathString._NonNullTrim();

            if (pathString._IsEmpty())
            {
                throw new ArgumentNullException(nameof(pathString));
            }

            pathString = PathParser.NormalizeDirectorySeparator(pathString, true);

            if (PathParser.IsAbsolutePath(pathString))
            {
                return(pathString);
            }
            else
            {
                pathString = "/" + PathParser.Linux.NormalizeDirectorySeparator(pathString, true);

                string[] elements = PathParser.Linux.SplitAbsolutePathToElementsUnixStyle(pathString);

                string tmp = PathParser.Linux.BuildAbsolutePathStringFromElements(elements);

                tmp = PathParser.Linux.NormalizeDirectorySeparator(tmp, true);

                if (tmp[0] != '/')
                {
                    throw new ApplicationException("tmp[0] != '/'");
                }

                tmp = tmp.Substring(1);

                tmp = PathParser.Combine(Env.AppRootDir, tmp, true);

                return(tmp);
            }
        }