public void GetReceiveEventName_Test()
{
var target = new ClusterMessage();
target.Header.EventName = "TEST";
target.GetReceiveEventName().Should().Be("Received.TEST");
}
private void ReceiveFileTransferRequest(ClusterMessage envelope, FileTransferEnvelope request)
{
using (var stream = new MemoryStream(request.Contents))
{
// TODO: Get more sophisticated with chunking, restart/retry, checksums, etc
var response = _messageBus.Request <PackageFileUploadRequest, PackageFileUploadResponse>(PackageFileUploadRequest.ChannelFromRemote, new PackageFileUploadRequest
{
Contents = stream,
FileName = request.FileName,
GroupName = new StitchGroupName(request.GroupName),
LocalOnly = true,
Adaptor = request.Adaptor
});
var outEnvelope = new ClusterMessageBuilder()
.FromNode()
.ToNode(envelope.Header.FromNetworkId)
.WithObjectPayload(new CommandReceipt
{
Success = response.IsSuccess,
ReplyToJobId = request.JobId,
ReplyToTaskId = request.TaskId
})
.Build();
_backplane.Send(outEnvelope);
}
}
private ClusterMessage GenerateCreateQueueMessage(ClusterCreateRequest request, Cluster newCluster, SshKey selectedSshKey, DatacenterNode selectedNode, Template template, int baseIp, int baseId)
{
var message = new ClusterMessage()
{
Pattern = "create",
Data = new Data()
{
Id = baseId,
Name = request.Name,
Features = new Feature()
{
Traefik = request.InstallTraefik,
},
Config = new Config()
{
User = "******",
Password = "******",
Ssh = new Ssh()
{
PrivateKey = selectedSshKey.Pem,
PublicKey = selectedSshKey.Public
}
},
Nodes = new List <Node>()
}
};
var master = new Node()
{
Id = baseId,
CpuCores = 2,
Master = true,
Disk = 30,
Memory = 2048,
Ip = $"10.0.{selectedNode.Id}.{baseIp}",
ProxmoxNode = selectedNode.Name,
Template = template.BaseTemplate
};
message.Data.Nodes.Add(master);
for (var i = 0; i < newCluster.Node; i++)
{
var node = new Node()
{
Id = baseId + i + 1,
CpuCores = newCluster.Cpu,
Master = false,
Disk = newCluster.Storage,
Memory = newCluster.Memory,
Ip = $"10.0.{selectedNode.Id}.{baseIp + i + 1}",
ProxmoxNode = selectedNode.Name,
Template = template.BaseTemplate
};
message.Data.Nodes.Add(node);
}
return(message);
}
public void IsSendable_NoHeader()
{
var target = new ClusterMessage();
target.Header = null;
target.IsSendable().Should().BeFalse();
}
private void HandleInternalPayloadObjects(ClusterMessage envelope)
{
if (envelope.PayloadObject == null)
{
return;
}
try
{
var internalObject = envelope.PayloadObject;
var fileTransferRequest = internalObject as FileTransferEnvelope;
if (fileTransferRequest != null)
{
_log.LogDebug("Received file transfer request from {0}", envelope.Header.FromNetworkId);
ReceiveFileTransferRequest(envelope, fileTransferRequest);
return;
}
_log.LogWarning("Received internal object of unhandled type {0} from {1}", internalObject.GetType().FullName, envelope.Header.FromNetworkId);
}
catch (Exception e)
{
_log.LogError(e, "Error decoding internal object of type {0}", envelope.PayloadObject.GetType().Name);
}
}
public void IsSendable_NoReturnAddress()
{
var target = new ClusterMessage();
target.Header.PayloadType = MessagePayloadType.Object;
target.PayloadObject = new object();
target.IsSendable().Should().BeFalse();
}
public void IsSendable_RawFramesNull()
{
var target = new ClusterMessage();
target.Header.PayloadType = MessagePayloadType.Raw;
target.RawFrames = null;
target.IsSendable().Should().BeFalse();
}
public void IsSendable_RawFramesEmpty()
{
var target = new ClusterMessage();
target.Header.PayloadType = MessagePayloadType.Raw;
target.RawFrames = new List <byte[]>();
target.IsSendable().Should().BeFalse();
}
public void IsSendable_CommandStringEmpty()
{
var target = new ClusterMessage();
target.Header.PayloadType = MessagePayloadType.CommandString;
target.CommandStrings = new List <string>();
target.IsSendable().Should().BeFalse();
}
public void IsSendable_ObjectPayloadNull()
{
var target = new ClusterMessage();
target.Header.PayloadType = MessagePayloadType.Object;
target.PayloadObject = null;
target.IsSendable().Should().BeFalse();
}
public Form1()
{
InitializeComponent();
ClusterMessage[] creatableMessages = new ClusterMessage[]
{
new CacheCleanAction(),
new PingMessage()
};
comboBox1.DataSource = creatableMessages;
}
public void FillInNetworkNodeId_Test()
{
var target = new ClusterMessage();
target.Header.PayloadType = MessagePayloadType.Object;
target.PayloadObject = new NodeStatus();
target.FillInNetworkNodeId("ABC");
var ns = (NodeStatus)target.PayloadObject;
ns.NetworkNodeId.Should().Be("ABC");
}
public void IsSendable_ToZoneNoZone()
{
var target = new ClusterMessage();
target.Header.PayloadType = MessagePayloadType.Object;
target.Header.FromNetworkId = "ABC";
target.Header.FromNodeId = "123";
target.PayloadObject = new object();
target.Header.ToType = TargetType.Zone;
target.IsSendable().Should().BeFalse();
}
/// <summary>
/// Handler for all messages received across the cluster.
/// TODO: should just be sent to the kernel
/// </summary>
void ClusterMessage_Received(ClusterMessage msg)
{
// keep track of all nodes detected, and announce ourselves
// whenever a new node is discovered
if (msg is HelloClusterMessage)
{
ClusterNode node = null;
node = (msg as HelloClusterMessage).Node;
if (node == null)
{
return;
}
lock (Current)
{
if (Current.Nodes.Contains(node) == false)
{
// this is for testing
Parent.Console.Add("Detected new node: " + node.ToString());
// announce to this specific ip in case it can't hear the broadcasts
if (node != ClusterNode.Local)
{
ClusterClient.Instance.Send(node.IP, new HelloClusterMessage()
{
Node = ClusterNode.Local
});
}
// add to the list
Current.Nodes.Add(node);
}
}
node.LastHeardFrom = DateTime.Now;
}
else if (msg is OSCClusterMessage)
{
// TODO: send this value to the OSC manager
var oscMessage = msg as OSCClusterMessage;
if (oscMessage == null)
{
return;
}
Parent.OSC.FromCluster(oscMessage.OSCAddress, oscMessage.OSCValues);
// TODO: cause implant events to notice this new value
}
}
public IPublishableMessage DecodePayloadObject(string channel, ClusterMessage envelope)
{
var objectType = envelope.PayloadObject.GetType();
// Get the ObjectsReceivedEvent<> object and .Object property
var eventType = typeof(ObjectReceivedEvent <>).MakeGenericType(objectType);
var eventObject = Activator.CreateInstance(eventType);
var objectsProperty = eventType.GetProperty(nameof(ObjectReceivedEvent <object> .Object));
objectsProperty.SetValue(eventObject, envelope.PayloadObject);
envelope.Header.PopulateReceivedEvent(eventObject as ReceivedEvent);
return(new PublishableMessage(channel, eventType, eventObject));
}
private static void PublishAutomatic(IBus myBus)
{
Console.WriteLine("Start publish 250 cluster messages");
for (int i = 0; i < 250; i++)
{
var msg = new ClusterMessage
{
Timestamep = DateTime.Now,
Host = System.Net.Dns.GetHostName(),
Message = $"Automatic message {i}"
};
myBus.Publish(msg);
System.Threading.Thread.Sleep(150);
}
}
private async Task ProcessMessage(ClusterMessage message)
{
try
{
switch (message.MessageType)
{
// Event occured on a node
case MessageType.NodeEvent:
message.MessageValue.NodeEventProcessing();
break;
// Single topic metadata, this is generally for the consumer
case MessageType.TopicMetadata:
await ProcessTopicMetadata(message.MessageValue.TopicPromise);
break;
// Full metadata required
case MessageType.Metadata:
await ProcessFullMetadata(message.MessageValue.Promise);
break;
// New topic seen
case MessageType.SeenTopic:
var seen = new HashSet <string>(_seenTopics)
{
message.MessageValue.SeenTopic
};
_seenTopics = seen;
break;
// Group coordinator
case MessageType.GroupCoordinator:
await ProcessGroupCoordinator(message.MessageValue.CoordinatorPromise);
break;
default:
throw new ArgumentOutOfRangeException("message", "Invalid message type");
}
}
catch (Exception ex)
{
InternalError(ex);
}
}
private void PublishPayloadObjects(string channel, ClusterMessage envelope)
{
if (envelope.PayloadObject == null)
{
return;
}
try
{
var message = new PayloadObjectDecoder().DecodePayloadObject(channel, envelope);
_log.LogDebug("Received object message of type {0} from {1}", envelope.PayloadObject.GetType().Name, envelope.Header.FromNetworkId);
_messageBus.PublishMessage(message);
}
catch (Exception e)
{
_log.LogError(e, "Error decoding PayloadObject of type {0}", envelope.PayloadObject.GetType().Name);
}
}
private static void PublishManual(IBus myBus)
{
var message = string.Empty;
do
{
Console.WriteLine("Enter the message or nothing to leave");
message = Console.ReadLine();
if (!string.IsNullOrEmpty(message))
{
var msg = new ClusterMessage
{
Timestamep = DateTime.Now,
Host = System.Net.Dns.GetHostName(),
Message = message
};
myBus.Publish(msg);
}
} while (string.IsNullOrEmpty(message));
}
public void Send(ClusterMessage envelope)
{
envelope.Header.FromNetworkId = _uuid.ToString();
envelope.Header.FromNodeId = _core.NodeId;
if (envelope.Header.FromType == TargetType.Node)
{
envelope.Header.FromEntityId = _core.NodeId;
}
if (!envelope.IsSendable())
{
return;
}
envelope.FillInNetworkNodeId(envelope.Header.FromNetworkId);
var message = _mapper.Map(envelope);
// If we have a proxy node ID, send the message there and let the proxy sort out
// further actions.
// Otherwise a zone type becomes a Shout and a Node type becomes a Whisper
if (!string.IsNullOrEmpty(envelope.Header.ProxyNodeNetworkId))
{
Guid uuid;
bool ok = Guid.TryParse(envelope.Header.ProxyNodeNetworkId, out uuid);
if (ok)
{
_zyre.Whisper(uuid, message);
}
}
else if (envelope.Header.ToType == TargetType.Cluster)
{
_zyre.Shout(Zones.ZoneAll, message);
}
else if (envelope.Header.ToType == TargetType.Zone)
{
_zyre.Shout(envelope.Header.ZoneName, message);
}
else if (envelope.Header.ToType == TargetType.Node)
{
_zyre.Whisper(envelope.Header.GetToNetworkUuid(), message);
}
}
public void QueueClusterDelete(ClusterMessage message)
{
var routingKey = "k3s_queue_delete";
PublishMessage(message, routingKey);
}
public void QueueClusterCreation(ClusterMessage message)
{
var routingKey = "k3s_queue";
PublishMessage(message, routingKey);
}
public ClusterMessageListViewItem(ClusterMessage message)
{
this.Text = _counter++.ToString();
this.SubItems.AddRange(new string[] { message.ToString(), message.SenderInfo.InstanceID, DateTime.UtcNow.ToString() });
}
public async Task <bool> CreateClusterAsync(ClusterCreateRequest request)
{
if ((await clusterRepository.ReadAsync(c => c.Name == request.Name)) != null)
{
throw new DuplicateException();
}
var selectedSshKey = await sshKeyRepository.ReadAsync(request.SshKeyId);
var selectedNode = await datacenterRepository.ReadAsync(f => f.Id == request.DeployNodeId);
var template = await templateRepository.ReadAsync(t => t.Id == request.SelectedTemplate);
var existingCluster = await clusterRepository.ReadsAsync(c => c.ProxmoxNodeId == request.DeployNodeId);
var domainDb = await domainNameRepository.ReadAsync(d => d.Id == request.LinkDomainId);
var baseIp = existingCluster.Any() ? GetBasedRangeIp(existingCluster) : 10;
var baseId = existingCluster.Any() ? ExtractBaseId(await clusterRepository.GetMaxOrder()) : 3000;
if (baseIp > 0 && baseId > 0)
{
var newCluster = new Cluster()
{
Cpu = request.Cpu,
Name = $"k3s-master-{request.Name}",
Node = request.Node,
Storage = request.Storage,
Domain = domainDb != null ? domainDb.Value : domain,
User = "******",
ProxmoxNodeId = selectedNode.Id,
OrderId = baseId,
Memory = request.Memory,
Ip = $"10.0.{selectedNode.Id}.{baseIp}",
SshKeyId = selectedSshKey.Id,
BaseTemplate = template.BaseTemplate
};
if ((await clusterRepository.InsertAsync(newCluster)) > 0)
{
var nodeList = new List <ClusterNode>();
for (int i = 0; i < request.Node; i++)
{
nodeList.Add(new ClusterNode()
{
ClusterId = newCluster.Id,
OrderId = baseId + i + 1,
Name = $"k3s-node{i + 1}-{request.Name}",
Ip = $"10.0.{selectedNode.Id}.{baseIp + i + 1}",
});
}
if ((await clusterNodeRepository.InsertsAsync(nodeList.ToArray()) == request.Node))
{
ClusterMessage message = GenerateCreateQueueMessage(request, newCluster, selectedSshKey, selectedNode, template, baseIp, baseId);
queueService.QueueClusterCreation(message);
await traefikRouterService.GenerateClusterBasicRules(newCluster);
}
return(true);
}
}
return(false);
}
public void Send(ClusterMessage message)
{
_messageBus.Publish(ClusterMessage.SendEventName, message);
}
public void IsSendable_Default()
{
var target = new ClusterMessage();
target.IsSendable().Should().BeFalse();
}
public ClusterMessageListViewItem(ClusterMessage message)
{
this.Text = _counter++.ToString();
this.SubItems.AddRange(new string[] { DateTime.Now.ToString(), message.ToString() });
}
public void GetReceiveEventName_NoEventName()
{
var target = new ClusterMessage();
target.GetReceiveEventName().Should().Be("Received");
}
