private ErrorSuccess<IVsixPackage, string> _LoadFromFile(string file, Logger log, ErrorSuccessFactory<IVsixPackage, string> ef)
{
log.Info($"Reading {file}");
ZipArchive zipFile;
try
{
zipFile = ZipFile.OpenRead(file);
}
catch (Exception ex)
{
log.Error($"{file} is not a zip archive.", ex);
return ef.Error($"{file} is not a zip archive: {ex.Message}");
}
using (zipFile)
{
var manifestEntry = zipFile.Entries.FirstOrDefault(entry => entry.FullName == Entry.Manifest);
if (manifestEntry == null)
{
return ef.Error($"{file} does not contain a {Entry.Manifest} entry.");
}
return _CreateFromZipManifest(file, manifestEntry, log, ef);
}
}
public Download(Uri uri, string key, CookieContainer cc, JObject song)
{
m_uri = uri;
m_key = key;
m_cc = cc;
m_song = song;
song["Status"] = "Opening file";
string filename = (string)song["ArtistName"] + " - " + (string)song["Name"] + ".mp3";
m_logger = new Logger(this.GetType().ToString() + " " + filename);
string dst = "";
string path = "";
if (Main.PATH.Length != 0)
path = Main.PATH + Path.DirectorySeparatorChar;
dst = path + filename;
try
{
m_path = dst;
m_fs = new FileStream(dst, FileMode.Create);
}
catch (Exception ex)
{
char[] invalf = Path.GetInvalidFileNameChars();
foreach (char c in invalf)
filename = filename.Replace(c, '_');
dst = path + filename;
try
{
m_path = dst;
m_fs = new FileStream(dst, FileMode.Create);
}
catch (Exception exc)
{
for (int i = 0; i < dst.Length; i++)
{
if (!Char.IsLetterOrDigit(dst[i]))
filename = filename.Replace(dst[i], '_');
dst = path + filename;
}
try
{
m_path = dst;
m_fs = new FileStream(dst, FileMode.Create);
}
catch (Exception exc2)
{
throw new Exception("Could not save the file buddy. (" + exc2.Message + ")");
}
}
}
m_logger.Info("Starting download");
song["Status"] = "Starting download";
Segment s = new Segment(uri, cc, key, 0, SEGMENT_SIZE-1, m_path);
m_segments.Add(s);
s.Progress += new EventHandler(s_Progress);
s.HeadersReceived += new Segment.HeadersReceivedHandler(s_HeadersReceived);
s.Start();
m_start = DateTime.Now;
}
private List<Tuple<uint, SiloAddress>> sortedBucketsList; // flattened sorted bucket list for fast lock-free calculation of CalculateTargetSilo
#endregion Fields
#region Constructors
internal VirtualBucketsRingProvider(SiloAddress siloAddr, int nBucketsPerSilo)
{
if (nBucketsPerSilo <= 0 )
throw new IndexOutOfRangeException("numBucketsPerSilo is out of the range. numBucketsPerSilo = " + nBucketsPerSilo);
logger = LogManager.GetLogger(typeof(VirtualBucketsRingProvider).Name);
statusListeners = new List<IRingRangeListener>();
bucketsMap = new SortedDictionary<uint, SiloAddress>();
sortedBucketsList = new List<Tuple<uint, SiloAddress>>();
myAddress = siloAddr;
numBucketsPerSilo = nBucketsPerSilo;
lockable = new object();
running = true;
myRange = RangeFactory.CreateFullRange();
logger.Info("Starting {0} on silo {1}.", typeof(VirtualBucketsRingProvider).Name, siloAddr.ToStringWithHashCode());
StringValueStatistic.FindOrCreate(StatisticNames.CONSISTENTRING_RING, ToString);
IntValueStatistic.FindOrCreate(StatisticNames.CONSISTENTRING_RINGSIZE, () => GetRingSize());
StringValueStatistic.FindOrCreate(StatisticNames.CONSISTENTRING_MYRANGE_RINGDISTANCE, () => String.Format("x{0,8:X8}", ((IRingRangeInternal)myRange).RangeSize()));
FloatValueStatistic.FindOrCreate(StatisticNames.CONSISTENTRING_MYRANGE_RINGPERCENTAGE, () => (float)((IRingRangeInternal)myRange).RangePercentage());
FloatValueStatistic.FindOrCreate(StatisticNames.CONSISTENTRING_AVERAGERINGPERCENTAGE, () =>
{
int size = GetRingSize();
return size == 0 ? 0 : ((float)100.0/(float) size);
});
// add myself to the list of members
AddServer(myAddress);
}
static void Main(string[] args)
{
ILayout simpleLayout = new SimpleLayout();
IAppender consoleAppender = new ConsoleAppender(simpleLayout);
ILogger logger = new Logger(consoleAppender);
logger.Error("Error parsing JSON");
logger.Info(string.Format("User {0} successfully registered.", "Pesho"));
Console.WriteLine(new string('-', 20));
//We create a second Appender and add it to the existing ILogger object
IFileAppender fileAppender = new FileAppender(simpleLayout);
fileAppender.File = "log.txt";
logger.AddAppender(fileAppender);
logger.Fatal("mscorlib.dll does not respond");
logger.Critical("No connection string found in App.config");
Console.WriteLine(new string('-', 20));
//We set the new XML Layout on each Appender that the Logger object uses
foreach (IAppender appender in logger.Appenders)
{
appender.Layout = new XmlLayout();
}
logger.Fatal("mscorlib.dll does not respond");
logger.Critical("No connection string found in App.config");
Console.WriteLine(new string('-', 20));
//We set the Report Level Minimum at Error
foreach (IAppender appender in logger.Appenders)
{
appender.ReportLevelMinimum = Enums.ReportLevel.Error;
}
logger.Info("Everything seems fine");
logger.Warning("Warning: ping is too high - disconnect imminent");
logger.Error("Error parsing request");
logger.Critical("No connection string found in App.config");
logger.Fatal("mscorlib.dll does not respond");
Console.WriteLine(new string('-', 20));
}
public override Task OnActivateAsync()
{
logger = LogManager.GetLogger(String.Format("GrainBasedReminderTable_{0}", Data.Address.ToString()), LoggerType.Runtime);
logger.Info("GrainBasedReminderTable {0} Activated. Full identity: {1}", Identity, Data.Address.ToFullString());
remTable = new InMemoryRemindersTable();
base.DelayDeactivation(TimeSpan.FromDays(10 * 365)); // Delay Deactivation for GrainBasedReminderTable virtually indefinitely.
return TaskDone.Done;
}
private static void ExampleOne()
{
ILayout simpleLayout = new SimpleLayout();
IAppender consoleAppender =
new ConsoleAppender(simpleLayout);
ILogger logger = new Logger(consoleAppender);
logger.Error("Error parsing JSON.");
logger.Info(string.Format("User {0} successfully registered.", "Pesho"));
}
public async Task Initialize(Guid serviceid, string connectionstring)
{
Name = "AzureTableBasedGossipChannel-" + ++sequenceNumber;
logger = LogManager.GetLogger(Name, LoggerType.Runtime);
logger.Info("Initializing Gossip Channel for ServiceId={0} using connection: {1}, SeverityLevel={2}",
serviceid, ConfigUtilities.RedactConnectionStringInfo(connectionstring), logger.SeverityLevel);
tableManager = await GossipTableInstanceManager.GetManager(serviceid, connectionstring, logger);
}
private ErrorSuccess<IVsixPackage, string> _CreateFromZipManifest(string file, ZipArchiveEntry manifestEntry, Logger log, ErrorSuccessFactory<IVsixPackage, string> ef)
{
var packageManifest = _TryGetPackageManifest(manifestEntry);
var vsixManifest = _TryGetVsixManifest(manifestEntry);
if (packageManifest != null)
{
log.Info("Loaded PackageManifest based manifest");
return ef.Success(new VsixWithPackageManifest(file, packageManifest));
}
if (vsixManifest != null)
{
log.Info("Loaded Vsix based manifest");
return ef.Success(new VsixWithVsixManifest(file, vsixManifest));
}
return ef.Error($"{file}\\{Entry.Manifest} is not a valid package manifest file.");
}
private static void _AddPackages(Uri root, string imageRoot, IEnumerable<IVsixPackage> packages, SyndicationFeed feed, Logger log)
{
// See https://msdn.microsoft.com/en-us/library/hh266717.aspx
var items = new List<SyndicationItem>();
feed.Items = items;
var orderedPackages = packages
.OrderBy(pkg => pkg.DisplayName)
.ThenBy(pkg => pkg.Id);
foreach (var pkg in orderedPackages)
{
log.Info($"Adding package {pkg.DisplayName} ({pkg.Id}) to feed");
var item = new SyndicationItem();
item.Id = pkg.Id;
item.Title = new TextSyndicationContent(pkg.DisplayName);
item.Summary = new TextSyndicationContent(pkg.Description);
item.PublishDate = new DateTimeOffset(File.GetLastWriteTimeUtc(pkg.File));
item.LastUpdatedTime = new DateTimeOffset(File.GetLastWriteTimeUtc(pkg.File));
item.Authors.Add(new SyndicationPerson { Name = pkg.Publisher });
item.Content = SyndicationContent.CreateUrlContent(root.MakeRelativeUri(new Uri(pkg.File)), "application/octet-stream");
_AddPreviewImages(root, imageRoot, item, pkg, log);
var ns = XNamespace.Get("http://schemas.microsoft.com/developer/vsx-syndication-schema/2010");
var xsi = XNamespace.Get("http://www.w3.org/2001/XMLSchema-instance");
var content = new XElement(
ns + "Vsix",
new XAttribute(XNamespace.Xmlns + "xsi", xsi),
new XElement(ns + "Id", pkg.Id),
new XElement(ns + "Version", pkg.Version),
new XElement(ns + "References"),
new XElement(
ns + "Rating",
new XAttribute(xsi + "nil", "true")),
new XElement(
ns + "RatingCount",
new XAttribute(xsi + "nil", "true")),
new XElement(
ns + "DownloadCount",
new XAttribute(xsi + "nil", "true")));
using (var stringReader = new StringReader(content.ToString()))
using (var reader = XmlReader.Create(stringReader))
{
item.ElementExtensions.Add(reader);
}
items.Add(item);
}
}
private static void ExampleTwo()
{
var simpleLayout = new SimpleLayout();
var consoleAppender = new ConsoleAppender(simpleLayout);
var fileAppender = new FileAppender(simpleLayout);
fileAppender.File = "log.txt";
var logger = new Logger(consoleAppender, fileAppender);
logger.Error("Error parsing JSON.");
logger.Info(string.Format("User {0} successfully registered.", "Pesho"));
logger.Warn("Warning - missing files.");
}
private static void ExampleFour()
{
var simpleLayout = new SimpleLayout();
var consoleAppender = new ConsoleAppender(simpleLayout);
consoleAppender.ReportLevel = ReportLevel.Error;
var logger = new Logger(consoleAppender);
logger.Info("Everything seems fine");
logger.Warn("Warning: ping is too high - disconnect imminent");
logger.Error("Error parsing request");
logger.Critical("No connection string found in App.config");
logger.Fatal("mscorlib.dll does not respond");
}
public int Launch()
{
CommonOptions commonOptions = _modeRunner.CommonOptions;
IDirectoryLocation outFolder = commonOptions.OutputDirectory;
var log = outFolder.GetFileLocation("CanvasLog.txt");
var error = outFolder.GetFileLocation("CanvasError.txt");
using (ILogger logger = new Logger(log, error))
{
try
{
logger.Info($"Running Canvas {_mode} {_version}");
logger.Info($"Command-line arguments: {string.Join(" ", _args)}");
var checkpointRunner =
GetCheckpointRunner(
logger,
outFolder,
commonOptions.StartCheckpoint,
commonOptions.StopCheckpoint,
commonOptions.WholeGenomeFasta);
using (var manager = checkpointRunner.Manager)
{
IDirectoryLocation loggingFolder = outFolder.CreateSubdirectory("Logging");
IsasConfiguration config = IsasConfiguration.GetConfiguration();
IWorkManager workManager = new LocalWorkManager(logger, loggingFolder, 0, config.MaximumMemoryGB, config.MaximumHoursPerProcess);
_modeRunner.Run(logger, checkpointRunner, workManager);
manager.CheckFinalState();
}
}
catch (StopCheckpointFoundException) { }
catch (Exception e)
{
logger.Error($"Canvas workflow error: {e}");
return -1;
}
}
return 0;
}
public void Error()
{
// arrange
var logger = new Logger();
var logs = new StringBuilder();
logger.SetWriter(new StringWriter(logs));
logger.AddCategory("error");
// act
logger.Debug("debug message");
logger.Info("info message");
logger.Error("error message");
// assert
Assert.Equal("error message", logs.ToString().Trim());
}
public Task InitializeMembershipTable(GlobalConfiguration config, bool tryInitTableVersion, Logger log)
{
logger = log;
deploymentId = config.DeploymentId;
storage = new DynamoDBStorage(config.DataConnectionString, log);
logger.Info(ErrorCode.MembershipBase, "Initializing AWS DynamoDB Membership Table");
return storage.InitializeTable(TABLE_NAME_DEFAULT_VALUE,
new List<KeySchemaElement>
{
new KeySchemaElement { AttributeName = SiloInstanceRecord.DEPLOYMENT_ID_PROPERTY_NAME, KeyType = KeyType.HASH },
new KeySchemaElement { AttributeName = SiloInstanceRecord.SILO_IDENTITY_PROPERTY_NAME, KeyType = KeyType.RANGE }
},
new List<AttributeDefinition>
{
new AttributeDefinition { AttributeName = SiloInstanceRecord.DEPLOYMENT_ID_PROPERTY_NAME, AttributeType = ScalarAttributeType.S },
new AttributeDefinition { AttributeName = SiloInstanceRecord.SILO_IDENTITY_PROPERTY_NAME, AttributeType = ScalarAttributeType.S }
});
}
public async Task InitializeMembershipTable(GlobalConfiguration config, bool tryInitTableVersion, Logger log)
{
logger = log;
AzureTableDefaultPolicies.MaxBusyRetries = config.MaxStorageBusyRetries;
LogFormatter.SetExceptionDecoder(typeof(StorageException), AzureStorageUtils.PrintStorageException);
tableManager = await OrleansSiloInstanceManager.GetManager(
config.DeploymentId, config.DataConnectionString);
// even if I am not the one who created the table,
// try to insert an initial table version if it is not already there,
// so we always have a first table version row, before this silo starts working.
if (tryInitTableVersion)
{
// ignore return value, since we don't care if I inserted it or not, as long as it is in there.
bool created = await tableManager.TryCreateTableVersionEntryAsync();
if(created) logger.Info("Created new table version row.");
}
}
public void TestLogging()
{
var config = new FileConfiguration
{
CreateDateFolder = true,
DaysToKeep = 3,
Path = AppDomain.CurrentDomain.BaseDirectory
};
var target = new FileTarget("Everything", config);
target.Enqueue(new LogEntry
{
CreatedAt = DateTime.Now,
LogLevel = LogLevel.Debug,
Message = "Hello world",
LoggedType = GetType(),
MethodName = MethodBase.GetCurrentMethod().Name,
ThreadId = Thread.CurrentThread.ManagedThreadId,
UserName = Thread.CurrentPrincipal.Identity.Name
?? Environment.UserName
});
var target2 = new PaddedFileTarget("EVeryone", config);
target2.Enqueue(new LogEntry
{
CreatedAt = DateTime.Now,
LogLevel = LogLevel.Debug,
Message = "Hello world",
LoggedType = GetType(),
MethodName = MethodBase.GetCurrentMethod().Name,
ThreadId = Thread.CurrentThread.ManagedThreadId,
UserName = Thread.CurrentPrincipal.Identity.Name
?? Environment.UserName
});
var logger = new Logger(GetType(), new[] {target2, target});
logger.Info("Hello");
logger.Debug("Hello");
logger.Warning("Hello");
logger.Error("Hello");
}
public void TestLogging()
{
var config = new FileConfiguration
{
CreateDateFolder = true,
DaysToKeep = 3,
Path = @"d:\logfiles"
};
var target = new FileTarget("Everything", config);
target.Enqueue(new LogEntry
{
CreatedAt = DateTime.Now,
LogLevel = LogLevel.Debug,
Message = "Hello world",
StackFrames = new StackTrace().GetFrames(),
ThreadId = Thread.CurrentThread.ManagedThreadId,
UserName = Thread.CurrentPrincipal.Identity.Name
?? Environment.UserName
});
var target2 = new PaddedFileTarget("EVeryone", config);
target2.Enqueue(new LogEntry
{
CreatedAt = DateTime.Now,
LogLevel = LogLevel.Debug,
Message = "Hello world",
StackFrames = new StackTrace().GetFrames(),
ThreadId = Thread.CurrentThread.ManagedThreadId,
UserName = Thread.CurrentPrincipal.Identity.Name
?? Environment.UserName
});
var logger = new Logger(GetType(), new[] {target2, target});
logger.Info("Hello");
logger.Debug("Hello");
logger.Warning("Hello");
logger.Error("Hello");
}
public Main()
{
InitializeComponent();
m_title = "SharkIt v0.8beta";
Text = m_title;
m_logger = new Logger(this.GetType().ToString());
m_logger.Info(m_title + " started");
PATH = Properties.Settings.Default.Path;
if (PATH.Length == 0)
PATH = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
userNameTB.Text = Properties.Settings.Default.Username;
passTB.Text = Properties.Settings.Default.Password;
/*
m_api = new API();
m_api.Ready += new API.ReadyHandler(m_api_Ready);
*/
// Use the icon from the application binary instead of saving another copy in resource file
this.Icon = Icon.ExtractAssociatedIcon(Application.ExecutablePath);
m_gs = new GS();
m_gs.RequestSent += new GS.RequestSentHandler(m_gs_RequestSent);
m_gs.GotSID += new GS.GotSIDHandler(gs_GotSID);
m_gs.GotToken += new GS.GotTokenHandler(gs_GotToken);
m_gs.LoggedIn += new GS.LoggedInHandler(m_gs_LoggedIn);
m_gs.GotPlaylists += new GS.GotPlaylistsHandler(m_gs_GotPlaylists);
m_gs.DownloadProgress += new GS.DownloadProgressHandler(m_gs_DownloadProgress);
m_gs.SongListFetched += new GS.SongListFetchedHandler(m_gs_SongListFetched);
playlistsCLB.SelectedValueChanged += new EventHandler(playlsitsCLB_SelectedValueChanged);
songsCLB.Format += new ListControlConvertEventHandler(songsCLB_Format);
playlistsCLB.Format += new ListControlConvertEventHandler(playlistsCLB_Format);
Timer t = new Timer();
t.Interval = 500;
t.Tick += new EventHandler(t_Tick);
t.Start();
Timer clipboardWatcher = new Timer();
clipboardWatcher.Interval = 100;
clipboardWatcher.Tick += new EventHandler(clipboardWatcher_Tick);
clipboardWatcher.Start();
}
public async Task InitializeMembershipTable(GlobalConfiguration config, bool tryInitTableVersion, Logger traceLogger)
{
logger = traceLogger;
deploymentId = config.DeploymentId;
if (logger.IsVerbose3) logger.Verbose3("SqlMembershipTable.InitializeMembershipTable called.");
//This initializes all of Orleans operational queries from the database using a well known view
//and assumes the database with appropriate defintions exists already.
orleansQueries = await RelationalOrleansQueries.CreateInstance(config.AdoInvariant, config.DataConnectionString);
// even if I am not the one who created the table,
// try to insert an initial table version if it is not already there,
// so we always have a first table version row, before this silo starts working.
if(tryInitTableVersion)
{
var wasCreated = await InitTableAsync();
if(wasCreated)
{
logger.Info("Created new table version row.");
}
}
}
public virtual void Init()
{
Log = new Logger(_info.Name ?? _info.WatcherType.Substring(_info.WatcherType.LastIndexOf('.') + 1));
string basePath = AppDomain.CurrentDomain.BaseDirectory;
//Input folder must be specified - either absolute, or relative
//(in which case it becomes a subfolder of the AppDomain current folder)
//Input must exist -- we do this to avoid creating random folders on disk
//if there's a typo in the configuration
_inputFolder = MakeRootedPath(basePath, _info.InputFolder);
//All other folders are children of input folder by default
//If a folder is overriden in a config file, do any of
// a) If override is rooted, use that explicit path
// b) Else append to input folder
if (!_info.NoDefaultFolders) {
_archiveFolder = SetupConfiguredFolder(_inputFolder, _info.ArchiveFolder, "processed");
if (!_info.DeleteMeansDelete)
_deletedFolder = SetupConfiguredFolder(_inputFolder, _info.DeletedFolder, "deleted");
_errorFolder = SetupConfiguredFolder(_inputFolder, _info.ErrorFolder, "error");
}
//Some processors want a separate output folder to output transformed files
//(as opposed to 'Processed' folder that archives unchanged input files after they are processed)
_outputFolder = MakeRootedPath(basePath, _info.OutputFolder);
//Some processors will use an URI for output
_uri = _info.Url;
if (_info.WatchSubfolders && (IsSubFolderOf(_inputFolder, _archiveFolder) || IsSubFolderOf(_inputFolder, _deletedFolder) || IsSubFolderOf(_inputFolder, _errorFolder))) {
_info.WatchSubfolders = false;
Log.Error("Will not watch subfolders as some of the configured folders are subfolders of input folder");
}
if (_info.NoDefaultFolders) {
Log.Info("Registering watcher '{0}': input from '{1}{2}', leave files in place.", _info.WatcherType, _inputFolder, _info.WatchSubfolders ? "\\*" + _info.Filter : "");
} else {
Log.Info("Registering watcher '{0}': input from '{1}{3}', archive to '{2}'", _info.WatcherType, _inputFolder, _archiveFolder, _info.WatchSubfolders ? "\\*" + _info.Filter : "");
}
if (!Directory.Exists(_inputFolder)) {
Log.Error("Input folder {0} does not exist. Please create the folder and restart this service.", _inputFolder);
}
if (!string.IsNullOrWhiteSpace(_outputFolder)) {
Log.Info("Transformed output will go into '{0}'", _outputFolder);
}
_watcher = new FileSystemWatcher(_inputFolder);
_watcher.Created += new FileSystemEventHandler(FileCreated);
if (!string.IsNullOrEmpty(_info.Filter)) {
_watcher.Filter = _info.Filter;
}
_watcher.IncludeSubdirectories = _info.WatchSubfolders;
_watcher.EnableRaisingEvents = true;
SetUpTimers();
}
private static SyndicationFeed _ConfigureFromExistingFeed(string file, Logger log)
{
try
{
using (var stream = File.OpenRead(file))
using (var reader = XmlReader.Create(stream))
{
var feed = SyndicationFeed.Load(reader);
log.Info($"Configured base feed information from {file}");
return feed;
}
}
catch
{
var feed = new SyndicationFeed();
feed.Id = Guid.NewGuid().ToString("D").ToUpper();
feed.Title = new TextSyndicationContent("");
feed.Generator = "VSGallery.AtomGenerator";
log.Info($"Existing feed file {file} not found, generating a new feed id");
return feed;
}
}
void TryLogger(Logger logger)
{
bool thrown = false;
string message = "msg";
try
{
logger.Always(message);
logger.Debug(message);
logger.Detailed(message);
logger.Error(message);
logger.Event(message);
logger.Fatal(message);
logger.Info(message);
logger.Warning(message);
}
catch (Exception)
{
thrown = true;
}
Assert.IsFalse(thrown);
}
// ---------------------------------------------------------------------
#region TestSelf
// ---------------------------------------------------------------------
/// <summary>
/// Simple self test.
/// </summary>
/// <returns>bool - true for success, false for failure.</returns>
public static bool TestSelf()
{
Logger log = new Logger("testSelf");
log.Verbosity = VerbosityLevel.Debug;
log.Info("Starting...");
//
// try parseSpec style
//
string parseSpec = "file=s, type:s, v, d, number=s";
string[] testArgs = {"-file", "fileName", "-type", "-v", "hello",
"-number", "-3.2"};
string errorMessage = null;
Opts opts = new Opts();
opts.ParseSpec = parseSpec;
log.Info("ParseSpec:");
opts.DisplayParseSpec(" ");
if (!opts.Parse(testArgs, out errorMessage))
{
log.Error("Unable to parse test string.");
log.Error("Error message is '{0}'", errorMessage);
return(false);
}
log.Info("After parse:");
opts.Display(" ");
// check results
if (opts.Options["file"] == null)
{
log.Error("Parse didn't get -file option");
return(false);
}
log.Info("-file argument was {0}", opts.Options["file"]);
if (opts.Options.ContainsKey("v")) log.Info("-v option was found");
else
{
log.Error("Parse didn't find -v option");
return(false);
}
if (opts.Options.ContainsKey("type"))
{
log.Info("-type arg was '{0}'", opts.Options["type"]);
}
else
{
log.Error("Parse didn't find -type option");
return(false);
}
//
// try usageSpec style
//
log.Info("----------------------------------------------------------");
log.Info("UsageSpec style of use.");
string usageSpec = "cmd -file fileName -type [typeName] [-v|-d] [-number num] file ...";
log.Info("Input usage: {0}", usageSpec);
opts.UsageSpec = usageSpec;
log.Info("UsageSpec:");
opts.DisplayParseSpec(" ");
if (!opts.Parse(testArgs, out errorMessage))
{
log.Error("Unable to parse test string.");
log.Error("Error message is '{0}'", errorMessage);
return(false);
}
if (opts.Options.ContainsKey("v"))
{
log.Info("-v was specified");
}
log.Info("After parse:");
opts.Display(" ");
// done
log.Info("Done.");
return(true);
}
private static void _WriteAtomFeed(string file, SyndicationFeed feed, Logger log)
{
var sb = new StringBuilder();
using (var stringStream = new StringWriter(sb))
using (var writer = XmlWriter.Create(stringStream))
{
var formatter = new Atom10FeedFormatter(feed);
formatter.WriteTo(writer);
}
log.Info($"Writing updated feed to {file}");
File.WriteAllText(file, XElement.Parse(sb.ToString()).ToString());
}
public void info_with_mixed_listeners()
{
var l1 = new RecordingLogListener { IsInfoEnabled = true };
var l2 = new RecordingLogListener { IsInfoEnabled = false, IsDebugEnabled = true };
var l3 = new RecordingLogListener { IsInfoEnabled = true };
var logger = new Logger(SystemTime.Default(), new ILogListener[] { l1, l2, l3 });
logger.Info("message {0}", 1);
logger.Info("message {0}", 2);
logger.Info(() => "message 3");
l1.InfoStrings.ShouldHaveTheSameElementsAs("message 1", "message 2", "message 3");
l3.InfoStrings.ShouldHaveTheSameElementsAs("message 1", "message 2", "message 3");
l2.InfoStrings.Any().ShouldBeFalse();
}
private static void _AddPreviewImages(Uri root, string imageRoot, SyndicationItem item, IVsixPackage pkg, Logger log)
{
var icon = pkg.TrySaveIcon(imageRoot);
var preview = pkg.TrySavePreviewImage(imageRoot);
if (icon != null)
{
log.Info($"Extracted icon to {icon}");
item.Links.Add(new SyndicationLink(root.MakeRelativeUri(icon), "icon", "", "", 0));
}
else
{
log.Info("No icon found");
}
if (preview != null)
{
log.Info($"Extracted preview image to {preview}");
item.Links.Add(new SyndicationLink(root.MakeRelativeUri(preview), "previewimage", "", "", 0));
}
else
{
log.Info("No preview image found");
}
}
public void logger_will_not_throw_an_exception_if_one_listener_blows_chunks_for_info()
{
var l1 = MockRepository.GenerateMock<ILogListener>();
var l2 = MockRepository.GenerateMock<ILogListener>();
var l3 = MockRepository.GenerateMock<ILogListener>();
l1.Stub(x => x.IsInfoEnabled).Return(true);
l2.Stub(x => x.IsInfoEnabled).Return(true);
l3.Stub(x => x.IsInfoEnabled).Return(true);
var logger = new Logger(new ILogListener[] { l1, l2, l3 }, NulloModifiers);
l2.Expect(x => x.Info("some message")).Throw(new NotSupportedException());
logger.Info("some message");
l1.AssertWasCalled(x => x.Info("some message"));
l2.AssertWasCalled(x => x.Info("some message"));
l3.AssertWasCalled(x => x.Info("some message"));
}
/// <summary>
/// Simple test of some ParseUtil methods.
/// </summary>
/// <returns>bool - true for all passed, false otherwise</returns>
public static bool TestSelf()
{
Logger log = new Logger("ParseUtil: TestSelf");
log.Info("Starting...");
StreamTokenizer tokenizer = new StreamTokenizer();
tokenizer.Verbosity = VerbosityLevel.Warn;
// FindMatch
ArrayList alist = new ArrayList();
tokenizer.TokenizeString("{ [ ] '}' }", alist);
foreach(Token t in alist) log.Debug("Token = {0}", t);
Token[] tarray = (Token[])alist.ToArray(typeof(Token));
int i = 0;
if (!FindMatch(tarray, ref i, '{'))
{
log.Error("FindMatch failed to match { char");
return(false);
}
if (i != 4)
{
log.Error("FindMatch got the wrong answer {0}", i);
return(false);
}
else log.Info("FindMatch worked.");
//
// try BuildArray
//
ArrayList tokens = new ArrayList();
tokenizer.TokenizeString("1 2 3 4 5", tokens);
foreach(Token t in tokens) log.Debug("Token = {0}", t);
i = 0;
Int16[] shorts = (short[])ParseUtil.BuildArray(tokens, ref i, typeof(Int16), null,
-1, log);
if (shorts == null)
{
log.Error("Unable to BuildArray of shorts.");
return(false);
}
log.Info("Parsed shorts:");
foreach(Int16 s in shorts)
{
log.Write("{0}, ", s);
}
log.WriteLine("");
//
// try BuildArray of floats, char terminated
//
tokens.Clear();
tokenizer.TokenizeString("1 2 ; 3 4", tokens);
foreach(Token t in tokens) log.Debug("Token = {0}", t);
i = 0;
Single[] floats = (float[])ParseUtil.BuildArray(tokens, ref i, typeof(Single),
new CharToken(';'), -1, log);
if (floats == null)
{
log.Error("Unable to BuildArray of floats.");
return(false);
}
log.Info("Parsed floats:");
foreach(float f in floats)
{
log.Write("{0}, ", f);
}
log.WriteLine("");
if (i != 2)
{
log.Error("BuildArray left i = {0} which is incorrect");
return(false);
}
//
// try BuildArray on high-precision floats
//
tokens.Clear();
float f1 = 1.23456f;
float f2 = 2.34567f;
tokenizer.TokenizeString(String.Format("{0:f6} {1:f6}", f1,f2), tokens);
foreach(Token t in tokens) log.Debug("Token = {0}", t);
i = 0;
floats = (float[])ParseUtil.BuildArray(tokens, ref i, typeof(Single),
null, -1, log);
if (floats == null)
{
log.Error("Unable to BuildArray of floats.");
return(false);
}
log.Info("Parsed floats:");
foreach(float f in floats)
{
log.Write("{0}, ", f);
}
log.WriteLine("");
if (floats[0] != f1)
{
log.Error("BuildArray produced float {0:f6} instead of {1:f6}",
floats[0], f1);
return(false);
}
//
// try BuildArray of chars, maxLength terminated
//
log.Info("Chars, terminated by maxLength");
tokens.Clear();
tokenizer.TokenizeString("12 2 ; 3 4", tokens);
foreach(Token t in tokens) log.Debug("Token = {0}", t);
i = 0;
char[] chars = (char[])ParseUtil.BuildArray(tokens, ref i, typeof(Char),
null, 3, log);
if (chars == null)
{
log.Error("Unable to BuildArray of chars.");
return(false);
}
log.Info("Parsed chars:");
foreach(char f in chars)
{
log.Write("{0}, ", f);
}
log.WriteLine("");
if (i != 4)
{
log.Error("BuildArray left i = {0} which is incorrect", i);
return(false);
}
//
// try BuildArray of hex numbers
//
log.Info("Hex numbers");
tokens.Clear();
tokenizer.Settings.ParseHexNumbers = true;
tokenizer.TokenizeString("0xfff, 0xffe", tokens);
foreach(Token t in tokens) log.Debug("Token = {0}", t);
i = 0;
ushort[] ushorts = (ushort[])ParseUtil.BuildArray(tokens, ref i, typeof(ushort),
null, 3, log);
if (ushorts == null)
{
log.Error("Unable to BuildArray of ushorts.");
return(false);
}
log.Info("Parsed ushorts:");
foreach(ushort us in ushorts)
{
log.Write("{0}, ", us);
}
log.WriteLine("");
// if (i != 4)
// {
// log.Error("BuildArray left i = {0} which is incorrect", i);
// return(false);
// }
log.Info("All PASSED");
return(true);
}
// ---------------------------------------------------------------------
#region TestSelf
// ---------------------------------------------------------------------
/// <summary>
/// Simple self test. See StreamTokenizerTestCase for full
/// tests.
/// </summary>
/// <returns>bool - true for success, false for failure.</returns>
public static bool TestSelf()
{
Logger log = new Logger("testSelf");
log.Verbosity = VerbosityLevel.Debug;
log.Info("Starting...");
string testString;
ArrayList tokens;
// setup tokenizer
StreamTokenizer tokenizer = new StreamTokenizer();
tokenizer.Settings.SetupForCodeParse();
tokenizer.Verbosity = VerbosityLevel.Debug;
//
// try string parse
//
log.Write("--------------------------------------------------------\n");
log.Info("string parse:");
log.Write("--------------------------------------------------------\n");
tokens = new ArrayList();
testString = "-1.2ej";
tokenizer.Settings.DoUntermCheck = false;
tokenizer.Settings.GrabWhitespace = false;
if (!tokenizer.TokenizeString(testString, tokens))
{
log.Error("Unable to parse into token vector.");
return (false);
}
foreach (Token t in tokens) log.Info("Token = '{0}'", t);
tokens = new ArrayList();
//
// try NextToken style
//
// log.Write("--------------------------------------------------------\n");
// log.Info("NextToken use");
// log.Write("--------------------------------------------------------\n");
//string fileName = "st-testSelf.tmp";
//testString = "this is a simple string";
//tokenizer.TextReader = new StringReader(testString);
//tokenizer.TextReader = File.OpenText(fileName);
//Token token;
//while (tokenizer.NextToken(out token)) log.Info("Token = '{0}'", token);
//
// try TokenizeFile
//
log.Write("--------------------------------------------------------\n");
log.Info("Tokenize missing file");
log.Write("--------------------------------------------------------\n");
string nonExistentFileName = "ThisFile better not exist";
bool caughtIt = false;
try
{
tokenizer.TokenizeFile(nonExistentFileName);
}
catch (FileNotFoundException e)
{
log.Info("Correctly caught exception: {0}: {1}", e.GetType(), e.Message);
caughtIt = true;
}
if (!caughtIt)
{
log.Error("Didn't get a file not found exception from TokenizeFile.");
return (false);
}
//
// test line numbers in tokens
//
// done
log.Info("Done.");
return (true);
}
/// <summary>
/// Speed test. This tests the speed of the parse.
/// </summary>
/// <returns>bool - true for ran, false for failed to run.</returns>
public static bool SpeedTest()
{
Logger log = new Logger("SpeedTest");
log.Verbosity = VerbosityLevel.Debug;
log.Info("Starting...");
Random rand = new Random(0);
// setup tokenizer
StreamTokenizer tokenizer = new StreamTokenizer();
tokenizer.Settings.ParseNumbers = true;
int nTokens = 1024;
MemoryStream ms;
StreamWriter writer;
// int
ms = new MemoryStream();
writer = new StreamWriter(ms);
for (int i = 0; i < nTokens; i++)
{
writer.WriteLine("{0}", (int)(rand.NextDouble() * 256));
}
writer.Flush();
ms.Position = 0;
Console.WriteLine("Parse {0} integers took {1:f2} ms", nTokens,
SpeedTestParse(tokenizer, ms));
// float
ms = new MemoryStream();
writer = new StreamWriter(ms);
ms.Position = 0;
for (int i = 0; i < nTokens; i++)
{
writer.WriteLine("{0:f9}", rand.NextDouble() * 10);
}
writer.Flush();
ms.Position = 0;
Console.WriteLine("Parse {0} floats took {1:f2} ms", nTokens,
SpeedTestParse(tokenizer, ms));
// exponential
ms = new MemoryStream();
writer = new StreamWriter(ms);
ms.Position = 0;
for (int i = 0; i < nTokens; i++)
{
writer.WriteLine("{0:e9}", rand.NextDouble() * 1000);
}
writer.Flush();
ms.Position = 0;
Console.WriteLine("Parse {0} exponential floats took {1:f2} ms", nTokens,
SpeedTestParse(tokenizer, ms));
// words
ms = new MemoryStream();
writer = new StreamWriter(ms);
for (int i = 0; i < nTokens; i++)
{
writer.WriteLine("foo ");
}
writer.Flush();
ms.Position = 0;
Console.WriteLine("Parse {0} words took {1:f2} ms", nTokens,
SpeedTestParse(tokenizer, ms));
// hex
ms = new MemoryStream();
writer = new StreamWriter(ms);
for (int i = 0; i < nTokens; i++)
{
writer.WriteLine("0x{0:x}", (int)(rand.NextDouble() * 256));
}
writer.Flush();
ms.Position = 0;
Console.WriteLine("Parse {0} hex numbers took {1:f2} ms", nTokens,
SpeedTestParse(tokenizer, ms));
// Console.WriteLine("Buffer to parse is:");
// Console.WriteLine("{0}", Encoding.ASCII.GetString(ms.GetBuffer()));
return (true);
}
