/// <summary>
/// Asynchronously creates an entity from a Splunk atom feed
/// <see cref= "Response"/>.
/// </summary>
/// <typeparam name="TEntity">
/// Type of the entity.
/// </typeparam>
/// <param name="context">
/// An object representing a Splunk server session.
/// </param>
/// <param name="response">
/// An object representing a Splunk atom feed response.
/// </param>
/// <returns>
/// The <see cref="BaseEntity<TResource>"/> created.
/// </returns>
internal static async Task <TEntity> CreateAsync <TEntity>(Context context, Response response)
where TEntity : BaseEntity <TResource>, new()
{
var reader = response.XmlReader;
TEntity resourceEndpoint;
reader.Requires(await reader.MoveToDocumentElementAsync("feed", "entry").ConfigureAwait(false));
if (reader.Name == "entry")
{
var entry = new AtomEntry();
await entry.ReadXmlAsync(reader).ConfigureAwait(false);
resourceEndpoint = new TEntity();
resourceEndpoint.Initialize(context, entry, new Version(0, 0));
}
else
{
var feed = new AtomFeed();
await feed.ReadXmlAsync(reader).ConfigureAwait(false);
resourceEndpoint = new TEntity();
resourceEndpoint.Initialize(context, feed);
}
return(resourceEndpoint);
}
public void CanReadFeed()
{
using (var stream = new FileStream(AtomFeedPath, FileMode.Open, FileAccess.Read))
{
var reader = XmlReader.Create(stream, XmlReaderSettings);
var feed = new AtomFeed();
feed.ReadXmlAsync(reader).Wait();
}
}
public void CanReadFeed()
{
using (var stream = new FileStream(AtomFeedPath, FileMode.Open, FileAccess.Read))
{
var reader = XmlReader.Create(stream, XmlReaderSettings);
var feed = new AtomFeed();
feed.ReadXmlAsync(reader).Wait();
}
}
/// <summary>
/// Asynchronously updates the content of the current
/// <see cref="BaseEntity<TResource>"/>.
/// </summary>
/// <param name="response">
/// A Splunk atom feed <see cref="Response"/>.
/// </param>
/// <returns>
/// A <see cref="Task"/> representing the operation.
/// </returns>
protected internal virtual async Task <bool> ReconstructSnapshotAsync(Response response)
{
Contract.Requires <ArgumentNullException>(response != null);
var feed = new AtomFeed();
await feed.ReadXmlAsync(response.XmlReader).ConfigureAwait(false);
this.CreateSnapshot(feed);
return(true);
}
protected async Task UpdateSnapshotAsync(Response response)
{
var feed = new AtomFeed();
await feed.ReadXmlAsync(response.XmlReader);
if (feed.Entries.Count != 1)
{
throw new InvalidDataException(); // TODO: Diagnostics
}
this.Snapshot = new EntitySnapshot(feed.Entries[0]);
}
public virtual async Task GetAsync()
{
using (Response response = await this.Context.GetAsync(this.Namespace, this.ResourceName, this.args))
{
await response.EnsureStatusCodeAsync(System.Net.HttpStatusCode.OK);
var feed = new AtomFeed();
await feed.ReadXmlAsync(response.XmlReader);
this.data = new DataCache(this.Context, feed);
}
}
internal static async Task <TResource> CreateAsync <TResource>(Response response)
where TResource : BaseResource, new()
{
var feed = new AtomFeed();
await feed.ReadXmlAsync(response.XmlReader).ConfigureAwait(false);
var resource = new TResource();
resource.Initialize(feed);
return(resource);
}
/// <inheritdoc/>
public virtual async Task <ServerInfo> GetInfoAsync()
{
using (var response = await this.Context.GetAsync(this.Namespace, Info).ConfigureAwait(false))
{
await response.EnsureStatusCodeAsync(HttpStatusCode.OK).ConfigureAwait(false);
var feed = new AtomFeed();
await feed.ReadXmlAsync(response.XmlReader).ConfigureAwait(false);
var info = new ServerInfo(feed);
return(info);
}
}
/// <inheritdoc/>
public virtual async Task <ServerSettings> UpdateSettingsAsync(ServerSettingValues values)
{
using (var response = await this.Context.PostAsync(this.Namespace, Settings, values).ConfigureAwait(false))
{
await response.EnsureStatusCodeAsync(HttpStatusCode.OK).ConfigureAwait(false);
var feed = new AtomFeed();
await feed.ReadXmlAsync(response.XmlReader).ConfigureAwait(false);
var settings = new ServerSettings(feed);
return(settings);
}
}
/// <inheritdoc/>
public virtual async Task <ReadOnlyCollection <string> > GetCapabilitiesAsync()
{
using (var response = await this.Context.GetAsync(this.Namespace, AuthorizationCapabilities).ConfigureAwait(false))
{
await response.EnsureStatusCodeAsync(HttpStatusCode.OK).ConfigureAwait(false);
var feed = new AtomFeed();
await feed.ReadXmlAsync(response.XmlReader).ConfigureAwait(false);
if (feed.Entries.Count != 1)
{
throw new InvalidDataException(); // TODO: Diagnostics : cardinality violation
}
var entry = feed.Entries[0];
ReadOnlyCollection <dynamic> capabilities = entry.Content["Capabilities"];
return(new ReadOnlyCollection <string>(capabilities.Cast <string>().ToList()));
}
}
/// <summary>
/// Asynchronously retrieves the list of all Splunk system capabilities.
/// </summary>
/// <returns>
/// An object representing the list of all Splunk system capabilities.
/// </returns>
/// <remarks>
/// This method uses the <a href="http://goo.gl/kgTKvM">GET
/// authorization/capabilities</a> endpoint to construct a list of all
/// Splunk system capabilities.
/// </remarks>
public async Task<dynamic> GetCapabilitiesAsync()
{
using (var response = await this.Context.GetAsync(this.Namespace, AuthorizationCapabilities))
{
await response.EnsureStatusCodeAsync(HttpStatusCode.OK);
var feed = new AtomFeed();
await feed.ReadXmlAsync(response.XmlReader);
if (feed.Entries.Count != 1)
{
throw new InvalidDataException(); // TODO: Diagnostics
}
var entry = feed.Entries[0];
dynamic capabilities = entry.Content.Capabilities; // TODO: Static type (?)
return capabilities;
}
}
/// <inheritdoc/>
public virtual async Task<ServerInfo> GetInfoAsync()
{
using (var response = await this.Context.GetAsync(this.Namespace, Info).ConfigureAwait(false))
{
await response.EnsureStatusCodeAsync(HttpStatusCode.OK).ConfigureAwait(false);
var feed = new AtomFeed();
await feed.ReadXmlAsync(response.XmlReader).ConfigureAwait(false);
var info = new ServerInfo(feed);
return info;
}
}
/// <inheritdoc/>
public virtual async Task<ServerSettings> UpdateSettingsAsync(ServerSettingValues values)
{
using (var response = await this.Context.PostAsync(this.Namespace, Settings, values).ConfigureAwait(false))
{
await response.EnsureStatusCodeAsync(HttpStatusCode.OK).ConfigureAwait(false);
var feed = new AtomFeed();
await feed.ReadXmlAsync(response.XmlReader).ConfigureAwait(false);
var settings = new ServerSettings(feed);
return settings;
}
}
/// <inheritdoc/>
public virtual async Task<ServerSettings> GetSettingsAsync()
{
using (var response = await this.Context.GetAsync(this.Namespace, Settings))
{
await response.EnsureStatusCodeAsync(HttpStatusCode.OK);
var feed = new AtomFeed();
await feed.ReadXmlAsync(response.XmlReader);
var settings = new ServerSettings(feed);
return settings;
}
}
/// <summary>
/// Refreshes the cached state of the current <see cref="Entity<TEntity>"/>.
/// </summary>
public override async Task GetAsync()
{
//// TODO: This retry logic is for jobs. Parmeterize it and move it into the Job class
// FJR: I assume the retry logic is for jobs, since nothing else requires this. I suggest moving it
// into Job. Also, it's insufficient. If you're just trying to get some state, this will do it, but
// as of Splunk 6, getting a 200 and content back does not imply you have all the fields. For pivot
// support, they're now shoving fields in as they become ready, so you have to wait until the dispatchState
// field of the Atom entry reaches a certain point.
RequestException requestException = null;
for (int i = 3; i > 0; --i)
{
try
{
//// Guarantee: unique result because entities have specific namespaces
using (var response = await this.Context.GetAsync(this.Namespace, this.ResourceName))
{
//// TODO: Use Response.EnsureStatusCode. Is it true that gets always return HttpStatusCode.OK?
if (response.Message.StatusCode == HttpStatusCode.NoContent)
{
throw new RequestException(response.Message, new Message(MessageType.Warning, string.Format("Resource '{0}/{1}' is not ready.", this.Namespace, this.ResourceName)));
}
if (!response.Message.IsSuccessStatusCode)
{
throw new RequestException(response.Message, await Message.ReadMessagesAsync(response.XmlReader));
}
var reader = response.XmlReader;
await reader.ReadAsync();
if (reader.NodeType == XmlNodeType.XmlDeclaration)
{
await response.XmlReader.ReadAsync();
}
if (reader.NodeType != XmlNodeType.Element)
{
throw new InvalidDataException(); // TODO: Diagnostics
}
AtomEntry entry;
if (reader.Name == "feed")
{
AtomFeed feed = new AtomFeed();
await feed.ReadXmlAsync(reader);
int count = feed.Entries.Count;
foreach (var feedEntry in feed.Entries)
{
string id = feedEntry.Title;
id.Trim();
}
if (feed.Entries.Count != 1)
{
throw new InvalidDataException(); // TODO: Diagnostics
}
entry = feed.Entries[0];
}
else
{
entry = new AtomEntry();
await entry.ReadXmlAsync(reader);
}
this.Snapshot = new EntitySnapshot(entry);
}
return;
}
catch (RequestException e)
{
if (e.StatusCode != System.Net.HttpStatusCode.NoContent)
{
throw;
}
requestException = e;
}
await Task.Delay(500);
}
throw requestException;
}
