/// <summary>
/// GetAll the items in the table that correspond to the entity default partitionkey or the category
/// </summary>
/// <param name="table">Table object</param>
/// <param name="entity">Entity type being sought</param>
/// <param name="category">Category to be used instead of the default partition key</param>
/// <returns></returns>
public async Task <dynamic> GetAll(string category = null)
{
string partitionKey = GetPartitionKey(category);
_response = new ResponseMessage();
// clear all items from the entity
// _entity.ClearItems();
// Create the configs object in which to hold these items
Configs configs = new Configs();
// Retrieve all the items from the table
TableQuery <Config> query = new TableQuery <Config>().Where(
TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, partitionKey)
);
// Iterate around the table and get all the values
TableContinuationToken token = null;
do
{
TableQuerySegment <Config> resultSegment = await _table.ExecuteQuerySegmentedAsync(query, token);
token = resultSegment.ContinuationToken;
foreach (Config item in resultSegment.Results)
{
// _entity.AddItem(item.RowKey, item.Value);
configs.SetProperty(item.RowKey, item.Value);
}
} while (token != null);
// return all the items
// return _entity.GetItems();
return(configs);
}
public async Task <HttpResponseMessage> Process(HttpRequest req,
CloudTable table,
ILogger logger,
string category,
Microsoft.Azure.WebJobs.ExecutionContext executionContext)
{
// Initialise variables
HttpResponseMessage response = null;
ResponseMessage msg = new ResponseMessage();
StringBuilder db = new StringBuilder();
_logger = logger;
// The StarterKit will only response to GET requests
if (req.Method == "GET")
{
logger.LogInformation("StarterKit has been requested");
// Create a config object to pass to the dataservice
Config config = new Config(Constants.ConfigStorePartitionKey);
// Create a data service object to get all the data
DataService ds = new DataService(table, config);
string clientKeyFilename = string.Empty;
string validatorKeyFilename = string.Empty;
// Define the paths for the structure and then ensure they exist
chefRepoPath = Path.Combine(executionContext.FunctionDirectory, "chef-repo");
extrasPath = Path.Combine(chefRepoPath, "extras");
dotChefPath = Path.Combine(chefRepoPath, ".chef");
string keyFilename = string.Empty;
string keyPath = string.Empty;
string key = string.Empty;
// Delete the repo path if it already exists
// This is to prevent old files from being added to the zip that has been requseted
if (Directory.Exists(chefRepoPath))
{
logger.LogInformation("Deleting existing path: {0}", chefRepoPath);
Directory.Delete(chefRepoPath, true);
}
// Create the directories again
if (!Directory.Exists(extrasPath))
{
logger.LogInformation("Creating directory: {0}", extrasPath);
Directory.CreateDirectory(extrasPath);
}
if (!Directory.Exists(dotChefPath))
{
logger.LogInformation("Creating directory: {0}", dotChefPath);
Directory.CreateDirectory(dotChefPath);
}
// Get all the configuration items from the config store
config_store = await ds.GetAll(category);
config_store.DeriveServerURLs();
// Write out the org and user keys
WriteKey("org");
WriteKey("user");
// Patche the necessary templates
// Create the template compiler
Mustache.FormatCompiler compiler = new Mustache.FormatCompiler();
// Build up a dictionary of the files to be rendered and the base path to use
Dictionary <string, string> templates = new Dictionary <string, string>();
templates.Add("credentials.txt", chefRepoPath);
templates.Add("chef_extension.json", extrasPath);
templates.Add("knife.rb", dotChefPath);
string path;
string data;
Mustache.Generator generator;
foreach (KeyValuePair <string, string> entry in templates)
{
path = Path.Combine(executionContext.FunctionAppDirectory, "templates", entry.Key);
generator = compiler.Compile(File.ReadAllText(path));
data = generator.Render(config_store);
File.WriteAllText(Path.Combine(entry.Value, entry.Key), data);
}
// Create a json file of the config_store as this can be read by other languages if need be
path = Path.Combine(extrasPath, "credentials.json");
data = JsonConvert.SerializeObject(config_store, Formatting.Indented);
File.WriteAllText(path, data);
// Determine the path for the zip file
string zipPath = Path.Combine(executionContext.FunctionDirectory, "starter_kit.zip");
// Remove the file if it already exists
if (File.Exists(zipPath))
{
File.Delete(zipPath);
}
// Create the zip file from the chef repo directory
ZipFile.CreateFromDirectory(chefRepoPath, zipPath);
response = msg.CreateResponse(zipPath);
// delete the zip file and the chefrepo
Directory.Delete(chefRepoPath, true);
File.Delete(zipPath);
}
else
{
msg.SetError("HTTP Method not supported", true, HttpStatusCode.BadRequest);
response = msg.CreateResponse();
}
return(response);
}
public async Task <HttpResponseMessage> Process(HttpRequest req,
CloudTable table,
ILogger log,
string category)
{
HttpResponseMessage msg;
// Only respond to an HTTP Post
if (req.Method == "POST")
{
// Create dataservice to access data in the config table
Config config = new Config();
DataService ds = new DataService(table, config);
// Get all the settings for the CentralLogging partition
Configs config_store = await ds.GetAll(category);
Configs central_logging = await ds.GetAll("centralLogging");
// Get the body of the request
string body = await new StreamReader(req.Body).ReadToEndAsync();
string[] logs = body.Split('}');
// Create an instance of the LogAnalyticsWriter
LogAnalyticsWriter log_analytics_writer = new LogAnalyticsWriter(log, config_store, central_logging);
// Create an instance of AutomateLog which will hold the data that has been submitted
AutomateLog data = new AutomateLog();
// iterate around each item in the logs
string appended_item;
string log_name;
foreach (string item in logs)
{
appended_item = item;
if (!appended_item.EndsWith("}"))
{
appended_item += "}";
}
// output the item to the console
log.LogInformation(item);
// if the item is not empty, process it
if (!string.IsNullOrEmpty(item))
{
// Deserialise the item into the AutomateLog object
data = JsonConvert.DeserializeObject <AutomateLog>(appended_item as string);
// From this data create an AutomateMessage object
AutomateMessage automate_message = AutomateLogParser.ParseGenericLogMessage(data.MESSAGE_s, config_store.customer_name, config_store.subscription_id, log);
// if the message is known then submit to LogAnalytics
if (automate_message.sourcePackage.ToLower() != "uknown entry")
{
// Determine the log name of the message
log_name = automate_message.sourcePackage.Replace("-", "") + "log";
// Submit the data
log_analytics_writer.Submit(automate_message, log_name);
}
}
}
_response.SetMessage("Log data accepted");
msg = _response.CreateResponse();
}
else
{
_response.SetError("HTTP Method not supported", true, HttpStatusCode.BadRequest);
msg = _response.CreateResponse();
}
return(msg);
}
