public CreateCommand(SeqConnectionFactory connectionFactory, SeqCliConfig config)
{
_connectionFactory = connectionFactory ?? throw new ArgumentNullException(nameof(connectionFactory));
Options.Add(
"t=|title=",
"A title for the API key",
t => _title = ArgumentString.Normalize(t));
Options.Add(
"token=",
"A pre-allocated API key token; by default, a new token will be generated and written to `STDOUT`",
t => _token = ArgumentString.Normalize(t));
_properties = Enable <PropertiesFeature>();
Options.Add(
"filter=",
"A filter to apply to incoming events",
f => _filter = ArgumentString.Normalize(f));
Options.Add(
"minimum-level=",
"The minimum event level/severity to accept; the default is to accept all events",
v => _level = ArgumentString.Normalize(v));
Options.Add(
"use-server-timestamps",
"Discard client-supplied timestamps and use server clock values",
_ => _useServerTimestamps = true);
_connection = Enable <ConnectionFeature>();
_output = Enable(new OutputFormatFeature(config.Output));
}
public RenderCommand(SeqConnectionFactory connectionFactory, SeqCliConfig config)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
_connectionFactory = connectionFactory ?? throw new ArgumentNullException(nameof(connectionFactory));
Options.Add(
"i=|id=",
"The id of a single dashboard to render",
t => _id = ArgumentString.Normalize(t));
Options.Add("c=|chart=", "The title of a chart on the dashboard to render",
c => _chartTitle = ArgumentString.Normalize(c));
Options.Add("last=",
"A duration over which the chart should be rendered, e.g. `7d`; this will be aligned to an interval boundary; either `--last` or `--start` and `--end` must be specified",
v => _lastDuration = ArgumentString.Normalize(v));
Options.Add("by=",
"The time-slice interval for the chart data, as a duration, e.g. `1h`",
v => _intervalDuration = ArgumentString.Normalize(v));
_range = Enable <DateRangeFeature>();
_signal = Enable <SignalExpressionFeature>();
_timeout = Enable <TimeoutFeature>();
_output = Enable(new OutputFormatFeature(config.Output));
_connection = Enable <ConnectionFeature>();
}
int RunSync()
{
if (_name == null)
{
Log.Error("A profile name is required");
return(1);
}
if (_url == null)
{
Log.Error("A server URL is required");
return(1);
}
try
{
var config = SeqCliConfig.Read();
config.Profiles[_name] = new SeqCliConnectionConfig {
ServerUrl = _url, ApiKey = _apiKey
};
SeqCliConfig.Write(config);
return(0);
}
catch (Exception ex)
{
Log.Error("Could not create profile: {ErrorMessage}", Presentation.FormattedMessage(ex));
return(1);
}
}
public CreateCommand(SeqConnectionFactory connectionFactory, SeqCliConfig config)
{
_connectionFactory = connectionFactory ?? throw new ArgumentNullException(nameof(connectionFactory));
Options.Add(
"n=|name=",
"A unique name for the feed",
n => _name = ArgumentString.Normalize(n));
Options.Add(
"l=|location=",
"The feed location; this may be a NuGet v2 or v3 feed URL, or a local filesystem path on the Seq server",
l => _location = ArgumentString.Normalize(l));
Options.Add(
"u=|username="******"The username Seq should supply when connecting to the feed, if authentication is required",
n => _username = ArgumentString.Normalize(n));
Options.Add(
"p=|password="******"A feed password, if authentication is required; note that `--password-stdin` is more secure",
p => _password = ArgumentString.Normalize(p));
Options.Add(
"password-stdin",
"Read the feed password from `STDIN`",
_ => _passwordStdin = true);
_connection = Enable <ConnectionFeature>();
_output = Enable(new OutputFormatFeature(config.Output));
}
int RunSync()
{
if (_name == null)
{
Log.Error("A profile name is required");
return(1);
}
try
{
var config = SeqCliConfig.Read();
if (!config.Profiles.Remove(_name))
{
Log.Error("No profile with name {ProfileName} was found", _name);
return(1);
}
SeqCliConfig.Write(config);
return(0);
}
catch (Exception ex)
{
Log.Error("Could not create profile: {ErrorMessage}", Presentation.FormattedMessage(ex));
return(1);
}
}
public RunCommand(SeqCliConfig config)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
_serverUrl = config.Connection.ServerUrl;
Options.Add(
"d=|directory=",
"The directory containing .NET Standard assemblies; defaults to the current directory",
d => _dir = ArgumentString.Normalize(d) ?? _dir);
Options.Add(
"type=",
"The [SeqApp] plug-in type name; defaults to scanning assemblies for a single type marked with this attribute",
t => _type = ArgumentString.Normalize(t));
Options.Add(
"p={=}|property={=}",
"Specify name/value settings for the app, e.g. `-p [email protected] -p Subject=\"Alert!\"`",
(n, v) =>
{
var name = n.Trim();
var valueText = v?.Trim();
_settings.Add(name, valueText ?? "");
});
Options.Add(
"storage=",
"A directory in which app-specific data can be stored; defaults to the current directory",
d => _storage = ArgumentString.Normalize(d) ?? _storage);
Options.Add("s=|server=",
"The URL of the Seq server, used only for app configuration (no connection is made to the server); by default the `connection.serverUrl` value will be used",
v => _serverUrl = ArgumentString.Normalize(v) ?? _serverUrl);
Options.Add(
"server-instance=",
"The instance name of the Seq server, used only for app configuration; defaults to no instance name",
v => _seqInstanceName = ArgumentString.Normalize(v));
Options.Add(
"t=|title=",
"The app instance title, used only for app configuration; defaults to a placeholder title.",
v => _appInstanceTitle = ArgumentString.Normalize(v));
Options.Add(
"id=",
"The app instance id, used only for app configuration; defaults to a placeholder id.",
v => _appInstanceId = ArgumentString.Normalize(v));
Options.Add(
"read-env",
"Read app configuration and settings from environment variables, as specified in " +
"https://docs.datalust.co/docs/seq-apps-in-other-languages; ignores all options " +
"except --directory and --type",
_ => _readEnv = true);
}
static void List(SeqCliConfig config)
{
foreach (var(key, value) in ReadPairs(config))
{
Console.WriteLine($"{key}:");
Console.WriteLine($" {value}");
}
}
static void List(SeqCliConfig config)
{
foreach (var pr in ReadPairs(config))
{
Console.WriteLine($"{pr.Key}:");
Console.WriteLine($" {pr.Value}");
}
}
protected override void Load(ContainerBuilder builder)
{
builder.RegisterType <CommandLineHost>();
builder.RegisterAssemblyTypes(typeof(Program).GetTypeInfo().Assembly)
.As <Command>()
.WithMetadataFrom <CommandAttribute>();
builder.RegisterType <SeqConnectionFactory>();
builder.Register(c => SeqCliConfig.Read()).SingleInstance();
}
public ImportCommand(SeqConnectionFactory connectionFactory, SeqCliConfig config)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
_connectionFactory = connectionFactory ?? throw new ArgumentNullException(nameof(connectionFactory));
_fileInputFeature = Enable(new FileInputFeature("File to import"));
_connection = Enable <ConnectionFeature>();
}
protected override Task <int> Run()
{
var config = SeqCliConfig.Read();
foreach (var profile in config.Profiles.OrderBy(p => p.Key))
{
Console.WriteLine($"{profile.Key} ({profile.Value.ServerUrl})");
}
return(Task.FromResult(0));
}
public CreateCommand(SeqConnectionFactory connectionFactory, SeqCliConfig config)
{
_connectionFactory = connectionFactory ?? throw new ArgumentNullException(nameof(connectionFactory));
Options.Add(
"t=|title=",
"A title for the API key",
t => _title = ArgumentString.Normalize(t));
Options.Add(
"token=",
"A pre-allocated API key token; by default, a new token will be generated and written to `STDOUT`",
t => _token = ArgumentString.Normalize(t));
_properties = Enable <PropertiesFeature>();
Options.Add(
"filter=",
"A filter to apply to incoming events",
f => _filter = ArgumentString.Normalize(f));
Options.Add(
"minimum-level=",
"The minimum event level/severity to accept; the default is to accept all events",
v => _level = ArgumentString.Normalize(v));
Options.Add(
"use-server-timestamps",
"Discard client-supplied timestamps and use server clock values",
_ => _useServerTimestamps = true);
Options.Add(
"permissions=",
"A comma-separated list of permissions to delegate to the API key; valid permissions are `Ingest` (default), `Read`, `Write`, `Project` and `System`",
v => _permissions = ArgumentString.NormalizeList(v));
Options.Add(
"connect-username="******"A username to connect with, useful primarily when setting up the first API key",
v => _connectUsername = ArgumentString.Normalize(v));
Options.Add(
"connect-password="******"When `connect-username` is specified, a corresponding password",
v => _connectPassword = ArgumentString.Normalize(v));
Options.Add(
"connect-password-stdin",
"When `connect-username` is specified, read the corresponding password from `STDIN`",
_ => _connectPasswordStdin = true);
_connection = Enable <ConnectionFeature>();
_output = Enable(new OutputFormatFeature(config.Output));
}
public ListCommand(SeqConnectionFactory connectionFactory, SeqCliConfig config)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
_connectionFactory = connectionFactory ?? throw new ArgumentNullException(nameof(connectionFactory));
_output = Enable(new OutputFormatFeature(config.Output));
_connection = Enable <ConnectionFeature>();
}
static void Set(SeqCliConfig config, string key, string value)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
var steps = key.Split('.');
if (steps.Length != 2)
{
throw new ArgumentException("The format of the key is incorrect; run the command without any arguments to view all keys.");
}
var first = config.GetType().GetTypeInfo().DeclaredProperties
.Where(p => p.CanRead && p.GetMethod.IsPublic && !p.GetMethod.IsStatic)
.SingleOrDefault(p => Camelize(p.Name) == steps[0]);
if (first == null)
{
throw new ArgumentException("The key could not be found; run the command without any arguments to view all keys.");
}
var v = first.GetValue(config);
if (v is Dictionary <string, SeqCliConnectionConfig> )
{
throw new NotSupportedException("Use `seqcli profile create` to configure connection profiles.");
}
var second = v.GetType().GetTypeInfo().DeclaredProperties
.Where(p => p.CanRead && p.GetMethod.IsPublic && !p.GetMethod.IsStatic)
.SingleOrDefault(p => Camelize(p.Name) == steps[1]);
if (second == null)
{
throw new ArgumentException("The key could not be found; run the command without any arguments to view all keys.");
}
if (!second.SetMethod.IsPublic)
{
throw new ArgumentException("The value is not writeable.");
}
var targetValue = Convert.ChangeType(value, second.PropertyType);
second.SetValue(v, targetValue);
}
public TailCommand(SeqConnectionFactory connectionFactory, SeqCliConfig config)
{
_connectionFactory = connectionFactory ?? throw new ArgumentNullException(nameof(connectionFactory));
Options.Add(
"f=|filter=",
"An optional server-side filter to apply to the stream, for example `@Level = 'Error'`",
v => _filter = v);
_output = Enable(new OutputFormatFeature(config.Output));
_signal = Enable <SignalExpressionFeature>();
_connection = Enable <ConnectionFeature>();
}
public ListCommand(SeqConnectionFactory connectionFactory, SeqCliConfig config)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
_connectionFactory = connectionFactory ?? throw new ArgumentNullException(nameof(connectionFactory));
_entityIdentity = Enable(new EntityIdentityFeature("workspace", "list"));
_entityOwner = Enable(new EntityOwnerFeature("workspace", "list", _entityIdentity));
_output = Enable(new OutputFormatFeature(config.Output));
_connection = Enable <ConnectionFeature>();
}
public QueryCommand(SeqConnectionFactory connectionFactory, SeqCliConfig config)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
_connectionFactory = connectionFactory ?? throw new ArgumentNullException(nameof(connectionFactory));
Options.Add("q=|query=", "The query to execute", v => _query = v);
_range = Enable <DateRangeFeature>();
_signal = Enable <SignalExpressionFeature>();
Options.Add("timeout=", "The query execution timeout in milliseconds", v => _timeoutMS = int.Parse(v?.Trim() ?? "0"));
_output = Enable(new OutputFormatFeature(config.Output));
_connection = Enable <ConnectionFeature>();
}
public ListCommand(SeqConnectionFactory connectionFactory, SeqCliConfig config)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
_connectionFactory = connectionFactory ?? throw new ArgumentNullException(nameof(connectionFactory));
Options.Add(
"i=|id=",
"The id of a single retention policy to list",
id => _id = id);
_output = Enable(new OutputFormatFeature(config.Output));
_connection = Enable <ConnectionFeature>();
}
public CreateCommand(SeqConnectionFactory connectionFactory, SeqCliConfig config)
{
_connectionFactory = connectionFactory ?? throw new ArgumentNullException(nameof(connectionFactory));
Options.Add(
"n=|name=",
"A unique username for the user",
u => _username = ArgumentString.Normalize(u));
Options.Add(
"d=|display-name=",
"A long-form name to aid in identifying the user",
d => _displayName = ArgumentString.Normalize(d));
Options.Add(
"f=|filter=",
"A view filter that limits the events visible to the user",
f => _filter = ArgumentString.Normalize(f));
Options.Add(
"r=|role=",
"The title of a role that grants the user permissions on the server; if not specified, the default new user role will be assigned",
r => _roleTitle = ArgumentString.Normalize(r));
Options.Add(
"e=|email=",
"The user's email address (enables a Gravatar image for the user)",
e => _emailAddress = ArgumentString.Normalize(e));
Options.Add(
"p=|password="******"An initial password for the user, if username/password authentication is in use; note that `--password-stdin` is more secure",
p => _password = ArgumentString.Normalize(p));
Options.Add(
"password-stdin",
"Read the initial password for the user from `STDIN`, if username/password authentication is in use",
_ => _passwordStdin = true);
Options.Add(
"no-password-change",
"Don't force the user to change their password at next login",
_ => _noPasswordChange = true);
_connection = Enable <ConnectionFeature>();
_output = Enable(new OutputFormatFeature(config.Output));
}
bool _deleteAllEvents; // Currently the only supported option
public CreateCommand(SeqConnectionFactory connectionFactory, SeqCliConfig config)
{
_connectionFactory = connectionFactory ?? throw new ArgumentNullException(nameof(connectionFactory));
Options.Add(
"after=",
"A duration after which the policy will delete events, e.g. `7d`",
v => _afterDuration = ArgumentString.Normalize(v));
Options.Add(
"delete-all-events",
"The policy should delete all events (currently the only supported option)",
_ => _deleteAllEvents = true);
_connection = Enable <ConnectionFeature>();
_output = Enable(new OutputFormatFeature(config.Output));
}
public ImportCommand(SeqConnectionFactory connectionFactory, SeqCliConfig config)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
_connectionFactory = connectionFactory ?? throw new ArgumentNullException(nameof(connectionFactory));
Options.Add(
"merge",
"Update signals that have ids matching those in the imported data; the default is to always create new signals",
_ => _merge = true);
_fileInputFeature = Enable(new FileInputFeature("File to import"));
_entityOwner = Enable(new EntityOwnerFeature("signal", "import"));
_connection = Enable <ConnectionFeature>();
}
public SearchCommand(SeqConnectionFactory connectionFactory, SeqCliConfig config)
{
_connectionFactory = connectionFactory ?? throw new ArgumentNullException(nameof(connectionFactory));
Options.Add(
"f=|filter=",
"A filter to apply to the search, for example `Host = 'xmpweb-01.example.com'`",
v => _filter = v);
Options.Add(
"c=|count=",
$"The maximum number of events to retrieve; the default is {_count}",
v => _count = int.Parse(v, CultureInfo.InvariantCulture));
_range = Enable <DateRangeFeature>();
_output = Enable(new OutputFormatFeature(config.Output));
_signal = Enable <SignalExpressionFeature>();
_connection = Enable <ConnectionFeature>();
}
static void Set(SeqCliConfig config, string key, string value)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
var steps = key.Split('.');
if (steps.Length != 2)
{
throw new ArgumentException("The format of the key is incorrect; run the command without any arguments to view all keys.");
}
var first = config.GetType().GetTypeInfo().DeclaredProperties
.Where(p => p.GetMethod.IsPublic && !p.GetMethod.IsStatic)
.SingleOrDefault(p => Camelize(p.Name) == steps[0]);
if (first == null)
{
throw new ArgumentException("The key could not be found; run the command without any arguments to view all keys.");
}
var v = first.GetValue(config);
var second = v.GetType().GetTypeInfo().DeclaredProperties
.Where(p => p.GetMethod.IsPublic && p.SetMethod.IsPublic && !p.GetMethod.IsStatic)
.SingleOrDefault(p => Camelize(p.Name) == steps[1]);
if (second == null)
{
throw new ArgumentException("The key could not be found; run the command without any arguments to view all keys.");
}
var targetValue = Convert.ChangeType(value, second.PropertyType);
second.SetValue(v, targetValue);
}
static void Print(SeqCliConfig config, string key)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
var pr = ReadPairs(config).SingleOrDefault(p => p.Key == key);
if (pr.Key == null)
{
throw new ArgumentException($"Option {key} not found.");
}
Console.WriteLine(pr.Value);
}
protected override Task <int> Run()
{
var verb = "read";
try
{
var config = SeqCliConfig.Read();
if (_key != null)
{
if (_clear)
{
verb = "clear";
Clear(config, _key);
SeqCliConfig.Write(config);
}
else if (_value != null)
{
verb = "update";
Set(config, _key, _value);
SeqCliConfig.Write(config);
}
else
{
Print(config, _key);
}
}
else
{
List(config);
}
return(Task.FromResult(0));
}
catch (Exception ex)
{
Log.Error(ex, "Could not {Verb} config: {ErrorMessage}", verb, Presentation.FormattedMessage(ex));
return(Task.FromResult(1));
}
}
public DefineCommand(SeqCliConfig config)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
Options.Add(
"d=|directory=",
"The directory containing .NET Standard assemblies; defaults to the current directory",
d => _dir = ArgumentString.Normalize(d) ?? _dir);
Options.Add(
"type=",
"The [SeqApp] plug-in type name; defaults to scanning assemblies for a single type marked with this attribute",
t => _type = ArgumentString.Normalize(t));
Options.Add(
"indented",
"Format the definition over multiple lines with indentation",
_ => _indented = true);
}
public CreateCommand(SeqConnectionFactory connectionFactory, SeqCliConfig config)
{
_connectionFactory = connectionFactory ?? throw new ArgumentNullException(nameof(connectionFactory));
Options.Add(
"t=|title=",
"A title for the workspace",
t => _title = ArgumentString.Normalize(t));
Options.Add(
"description=",
"A description for the workspace",
d => _description = ArgumentString.Normalize(d));
Options.Add(
"dashboard=",
"The id of a dashboard to include in the workspace",
d => _dashboards.Add(ArgumentString.Normalize(d)));
Options.Add(
"query=",
"The id of a saved query to include in the workspace",
s => _queries.Add(ArgumentString.Normalize(s)));
Options.Add(
"signal=",
"The id of a signal to include in the workspace",
s => _signals.Add(ArgumentString.Normalize(s)));
Options.Add(
"protected",
"Specify that the workspace is editable only by administrators",
_ => _isProtected = true);
_connection = Enable <ConnectionFeature>();
_output = Enable(new OutputFormatFeature(config.Output));
}
public CreateCommand(SeqConnectionFactory connectionFactory, SeqCliConfig config)
{
_connectionFactory = connectionFactory ?? throw new ArgumentNullException(nameof(connectionFactory));
Options.Add(
"t=|title=",
"A title for the signal",
t => _title = ArgumentString.Normalize(t));
Options.Add(
"description=",
"A description for the signal",
d => _description = ArgumentString.Normalize(d));
Options.Add(
"f=|filter=",
"Filter to associate with the signal",
f => _filter = ArgumentString.Normalize(f));
Options.Add(
"group=",
"An explicit group name to associate with the signal; the default is to infer the group from the filter",
g => _group = ArgumentString.Normalize(g));
Options.Add(
"no-group",
"Specify that no group should be inferred; the default is to infer the group from the filter",
_ => _noGrouping = true);
Options.Add(
"protected",
"Specify that the signal is editable only by administrators",
_ => _isProtected = true);
_connection = Enable <ConnectionFeature>();
_output = Enable(new OutputFormatFeature(config.Output));
}
public RunCommand(SeqCliConfig config)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
_serverUrl = config.Connection.ServerUrl;
Options.Add(
"d=|directory=",
"The directory containing .NET Standard assemblies; defaults to the current directory",
d => _dir = ArgumentString.Normalize(d) ?? _dir);
Options.Add(
"t|type=",
"The [SeqApp] plug-in type name; defaults to scanning assemblies for a single type marked with this attribute",
t => _type = ArgumentString.Normalize(t));
Options.Add(
"p={=}|property={=}",
"Specify name/value settings for the app, e.g. `-p [email protected] -p Subject=\"Alert!\"`",
(n, v) =>
{
var name = n.Trim();
var valueText = v?.Trim();
_settings.Add(name, valueText ?? "");
});
Options.Add("s=|server=",
"The URL of the Seq server, used only for app configuration (no connection is made to the server); by default the `connection.serverUrl` value will be used",
v => _serverUrl = ArgumentString.Normalize(v) ?? _serverUrl);
Options.Add(
"storage=",
"A directory in which app-specific data can be stored; defaults to the current directory",
d => _storage = ArgumentString.Normalize(d) ?? _storage);
}
protected override Task <int> Run()
{
try
{
var config = SeqCliConfig.Read();
if (_key != null)
{
if (_clear)
{
Clear(config, _key);
SeqCliConfig.Write(config);
}
else if (_value != null)
{
Set(config, _key, _value);
SeqCliConfig.Write(config);
}
else
{
Print(config, _key);
}
}
else
{
List(config);
}
return(Task.FromResult(0));
}
catch (Exception ex)
{
Log.Fatal(ex, "Could not update config: {ErrorMessage}", ex.Message);
return(Task.FromResult(1));
}
}
