static void Main(string[] args)
{
var client = new Client("https://www.mystore.com/mm5/json.mvc", "MY_API_TOKEN", "MY_SIGNING_KEY");
client.DefaultStoreCode = "STORE_CODE";
/// If you create a custom module or want to hook into an existing modules API functionality it exposes you can
/// use the Module request class to call into the module.
var request = new ModuleRequest(client);
// Set the module you wish to call into
request.SetModuleCode("mymodule");
// Set the function name you wish to call (defined by your modules json_api feature)
request.SetModuleFunction("MyModuleFunction");
/// Add custom parameters to the request using the setModuleField method
request.SetModuleField("MyModuleField", "Foo")
.SetModuleField("MyModuleField_Int", 1)
.SetModuleField("MyModuleField_Decimal", 2.99);
// Send the request
ModuleResponse response = request.Send();
if (!response.IsSuccess())
{
Console.WriteLine("Error: {0}: {1}", response.GetErrorCode(), response.GetErrorMessage());
}
else
{
Console.WriteLine("Success");
}
}
/// <summary>
/// 添加子节点内
/// </summary>
/// <param name="node">节点</param>
private void AddChildren(ModuleResponse node)
{
if (node == null)
{
return;
}
node.Children = GetChildren(node.Id).Select(ToNode).ToList();
foreach (var child in node.Children)
{
AddChildren(child);
}
}
/// <summary>
/// 转换为树节点
/// </summary>
/// <param name="entity">实体</param>
private ModuleResponse ToNode(Module entity)
{
var result = new ModuleResponse()
{
Id = entity.Id,
ApplicationId = entity.ApplicationId.SafeValue(),
ParentId = entity.ParentId,
Name = entity.Name,
Url = entity.Url,
Icon = entity.Icon,
Remark = entity.Remark,
Enabled = entity.Enabled,
SortId = entity.SortId
};
return(result);
}
public async Task Handle(LoadModule moduleRequest, string replyTo, string correlationId)
{
Console.WriteLine($"[i] Got New LoadModule Message.");
Module module = _taskRepository.GetModule(moduleRequest.Name, moduleRequest.Language);
string moduleb64 = "";
string workingDir = Path.Join(Settings.ModulesPath, Settings.LanguageName);
string exitCode = "0";
string output = "";
string error = "";
if (!String.IsNullOrEmpty(module.BuildCommand))
{
Dictionary <string, string> cmdResult = RunCommand(workingDir, module.BuildCommand);
exitCode = cmdResult["ExitCode"];
output = cmdResult["Output"];
error = cmdResult["Error"];
}
if (exitCode == "0")
{
byte[] moduleBytes = File.ReadAllBytes(Path.Join(workingDir, module.BuildLocation));
moduleb64 = Convert.ToBase64String(moduleBytes);
}
if (String.IsNullOrEmpty(moduleb64))
{
NewErrorMessage response = new NewErrorMessage();
response.Source = ".NET Build Server";
response.Message = $"Error building {moduleRequest.Name} module.";
response.Details = $"Stdout: {output}\n Stderr: {error}";
_eventBus.Publish(response, replyTo = null, correlationId = null);
}
else
{
ModuleResponse response = new ModuleResponse();
response.Success = true;
response.Contents = $"module {moduleRequest.Name} {moduleb64}";
_eventBus.Publish(response, replyTo, correlationId);
}
}
public static async Task <ModuleResponse> DetermineIfTriggering(
ILocationRepository locationRepository,
ILocationActionEventsRepository locationActionEventsRepository,
IMessagingService messagingService,
Module module)
{
var location = module.Location;
var triggeredFlag = false;
if (location.Armed && location.IsNotTriggered)
{
await locationRepository.TriggerLocation(location);
await messagingService.SendModuleTriggeredMessage(module);
var locationActionEvent = new LocationActionEvent
{
LocationId = location.Id,
Action = LocationActionEnum.Triggered
};
await locationActionEventsRepository.SaveLocationActionEvent(locationActionEvent);
triggeredFlag = true;
}
var moduleResponse = new ModuleResponse
{
Armed = location.Armed,
Triggered = triggeredFlag && !location.IsSilentAlarm
};
return(moduleResponse);
}
public async Task Handle(NewConsoleMessage newConsoleMessage, string replyTo, string correlationId)
{
// Reset Error stuff
error = false;
errorMessage = "";
// figure out what agent we're dealing with
Agent agent = _taskRepository.GetAgent(newConsoleMessage.AgentId);
agent.AgentType = _taskRepository.GetAgentType(agent.AgentTypeId);
// flesh out and save the ConsoleMessage object
ConsoleMessage consoleMessage = new ConsoleMessage();
consoleMessage.AgentId = newConsoleMessage.AgentId;
consoleMessage.UserId = newConsoleMessage.UserId;
consoleMessage.Agent = agent;
consoleMessage.User = _taskRepository.GetUser(consoleMessage.UserId.Value);
consoleMessage.Content = newConsoleMessage.Content;
consoleMessage.Display = newConsoleMessage.Display;
consoleMessage.Received = DateTime.UtcNow;
consoleMessage.Type = "AgentTask";
_taskRepository.Add(consoleMessage);
// Announce our new message to Rabbit
ConsoleMessageAnnouncement messageAnnouncement = new ConsoleMessageAnnouncement();
messageAnnouncement.Success = true;
messageAnnouncement.Username = consoleMessage.User.Username;
messageAnnouncement.ConsoleMessage = consoleMessage;
_eventBus.Publish(messageAnnouncement);
// These are the commands we allow. If one of these isn't the first part of a command
List <string> allowedActions = new List <string>();
allowedActions.Add("HELP");
allowedActions.Add("SHOW");
allowedActions.Add("LOAD");
allowedActions.Add("SET");
allowedActions.Add("USE");
allowedActions.Add("RUN");
allowedActions.Add("EXIT");
// we assume that the command is a RUN command
string action = "RUN";
string[] consoleMessageComponents = consoleMessage.Content.Split(' ');
if (consoleMessageComponents.Length > 0)
{
if (allowedActions.Contains(consoleMessageComponents[0].ToUpper()))
{
action = consoleMessageComponents[0].ToUpper();
}
}
// if this is a SHOW or HELP commmand, we won't be sending anything to the agent
// so lets take care of that here:
AgentDetails.Language = _taskRepository.GetLanguage(consoleMessage.Agent.AgentType.LanguageId);
AgentDetails.AvailableModules = _taskRepository.GetModules(AgentDetails.Language.Id);
AgentDetails.LoadedModules = _taskRepository.GetAgentModules(consoleMessage.AgentId);
AgentDetails.AgentType = consoleMessage.Agent.AgentType;
if (action == "HELP")
{
ConsoleMessage message = ProcessHelpMessage(consoleMessage);
_taskRepository.Add(message);
ConsoleMessageAnnouncement response = new ConsoleMessageAnnouncement();
response.Success = true;
response.Username = "******";
response.ConsoleMessage = message;
_eventBus.Publish(response);
}
else if (action == "SHOW")
{
ConsoleMessage message = ProcessShowMessage(consoleMessage);
_taskRepository.Add(message);
ConsoleMessageAnnouncement response = new ConsoleMessageAnnouncement();
response.Success = true;
response.Username = "******";
response.ConsoleMessage = message;
_eventBus.Publish(response);
}
else
{
// We'll be tasking the agent to do something so lets create an agentTask
AgentTask agentTask = new AgentTask();
agentTask.Action = action;
agentTask.AgentId = consoleMessage.AgentId;
agentTask.ConsoleMessageId = consoleMessage.Id;
agentTask.ConsoleMessage = consoleMessage;
agentTask.Agent = consoleMessage.Agent;
// Package the AgentTask into a envelope for seralization & encryption.
// Then process the ACTION and populate CONTENTS appropriately
Dictionary <String, String> outboundMessage = new Dictionary <String, String>();
outboundMessage.Add("AgentName", agentTask.Agent.Name);
outboundMessage.Add("Name", agentTask.Name);
outboundMessage.Add("Action", agentTask.Action);
// Message formats
// * load stdlib
// * load dotnet/stdlib
// * load transport/dns
if (agentTask.Action == "LOAD")
{
LoadModule msg = new LoadModule();
if (consoleMessageComponents[1].Contains("/"))
{
msg.Language = consoleMessageComponents[1].Split("/")[0];
msg.Name = consoleMessageComponents[1].Split("/")[0];
}
else
{
msg.Language = (_taskRepository.GetLanguage(consoleMessage.Agent.AgentType.LanguageId)).Name;
msg.Name = consoleMessageComponents[1];
}
bool LoadSuccess = false;
foreach (Module module in AgentDetails.AvailableModules)
{
if (String.Equals(module.Name, msg.Name, StringComparison.CurrentCultureIgnoreCase))
{
_eventBus.Publish(msg, null, null, true);
string message = _eventBus.ResponseQueue.Take();
ModuleResponse moduleResponse = JsonConvert.DeserializeObject <ModuleResponse>(message);
outboundMessage.Add("Command", moduleResponse.Contents);
LoadSuccess = true;
AgentUpdated agentUpdated = new AgentUpdated {
Success = true, Agent = agentTask.Agent
};
_eventBus.Publish(agentUpdated);
break;
}
}
if (!LoadSuccess)
{
error = true;
errorMessage = $"Module {msg.Name} is not a valid module. Use the 'show modules' command to view available modules";
}
}
// Message formats
// * set beacon:5
else if (agentTask.Action == "SET")
{
outboundMessage.Add("Command", consoleMessageComponents[1]);
}
else if (agentTask.Action == "EXIT")
{
outboundMessage.Add("Command", "exit");
}
// Example commands:
// * ls
// * ls "C:\Program Files"
// * ls /path:"C:\Program Files"
if (agentTask.Action == "RUN")
{
string submittedCommand = consoleMessage.Content;
string[] processedArgs = null;
// check to see if we have parameters (for example: ls /path:foo)
int index = submittedCommand.IndexOf(' ');
if (index > 0)
{
// change submittedCommand to just the first part of the command (ex: ls)
submittedCommand = submittedCommand.Substring(0, index);
string submittedArgs = consoleMessage.Content.Substring(index + 1);
if (submittedArgs.Length > 0)
{
processedArgs = SplitArguments(submittedArgs);
}
}
// Check if command is available
try
{
Command commandObject = _taskRepository.GetCommand(submittedCommand);
if (!AgentDetails.IsModuleLoaded(commandObject.Module))
{
error = true;
errorMessage = $"The module for this command isn't loaded. You can load it by running: 'load {commandObject.Module.Name}'";
}
}
catch
{
error = true;
errorMessage = $"{submittedCommand} is not a valid command for this agent. To view available commands, run: 'show commands'";
}
if (!error)
{
FactionCommand factionCommand = ProcessCommand(submittedCommand, processedArgs);
string command = factionCommand.Command;
if (factionCommand.Arguments.Count > 0)
{
command = $"{factionCommand.Command} {JsonConvert.SerializeObject(factionCommand.Arguments)}";
}
outboundMessage.Add("Command", command);
}
}
// If there's an error, send it back
if (error)
{
ConsoleMessage message = new ConsoleMessage();
message.AgentId = consoleMessage.AgentId;
message.AgentTaskId = agentTask.Id;
message.UserId = 1;
message.Type = "AgentTaskError";
message.Display = errorMessage;
_taskRepository.Add(message);
ConsoleMessageAnnouncement response = new ConsoleMessageAnnouncement();
response.Success = true;
response.Username = "******";
response.ConsoleMessage = message;
_eventBus.Publish(response);
}
// Else, create a new task for the agent
else
{
// update agentTask with final command format and save it
agentTask.Command = outboundMessage["Command"];
_taskRepository.Add(agentTask);
// update the incoming consoleMessage with this task Id
consoleMessage.AgentTaskId = agentTask.Id;
_taskRepository.Update(consoleMessage.Id, consoleMessage);
string jsonOutboundMessage = JsonConvert.SerializeObject(outboundMessage);
Dictionary <string, string> encCommand = Crypto.Encrypt(jsonOutboundMessage, agentTask.Id, agentTask.Agent.AesPassword);
// Create a AgentTaskMessage object with the seralized/encrypted message contents
AgentTaskMessage agentTaskMessage = new AgentTaskMessage();
agentTaskMessage.Agent = agentTask.Agent;
agentTaskMessage.Message = encCommand["encryptedMsg"];
agentTaskMessage.AgentId = consoleMessage.Agent.Id;
agentTaskMessage.AgentTaskId = agentTask.Id;
agentTaskMessage.AgentTask = agentTask;
agentTaskMessage.Hmac = encCommand["hmac"];
agentTaskMessage.Iv = encCommand["iv"];
agentTaskMessage.Sent = false;
_taskRepository.Add(agentTaskMessage);
}
}
}
private SonarQubeModule ToSonarQubeModule(ModuleResponse response) => new SonarQubeModule(response.Key, response.Name, response.Path);
private SonarQubeModule ToSonarQubeModule(ModuleResponse response) => new SonarQubeModule(response.Key, response.Name, FilePathNormalizer.NormalizeSonarQubePath(response.Path));
