// DiscoverTopology receives a discovery request from server and start probing the k8s.
func (handler *KubernetesServerMessageHandler) DiscoverTopology(serverMsg *comm.MediationServerMessage) {
//Discover the kubernetes topology
glog.V(3).Infof("Discover topology request from server.")
// 1. Get message ID
messageID := serverMsg.GetMessageID()
var stopCh chan struct{} = make(chan struct{})
go util.Until(func() { handler.keepDiscoverAlive(messageID) }, time.Second*10, stopCh)
defer close(stopCh)
// 2. Build discoverResponse
// must have kubeClient to do ParseNode and ParsePod
if handler.kubeClient == nil {
glog.V(3).Infof("kubenetes client is nil, error")
return
}
kubeProbe := probe.NewKubeProbe(handler.kubeClient)
nodeEntityDtos, err := kubeProbe.ParseNode()
if err != nil {
// TODO, should here still send out msg to server?
glog.Errorf("Error parsing nodes: %s. Will return.", err)
return
}
podEntityDtos, err := kubeProbe.ParsePod(api.NamespaceAll)
if err != nil {
// TODO, should here still send out msg to server? Or set errorDTO?
glog.Errorf("Error parsing pods: %s. Will return.", err)
return
}
appEntityDtos, err := kubeProbe.ParseApplication(api.NamespaceAll)
if err != nil {
glog.Errorf("Error parsing applications: %s. Will return.", err)
return
}
serviceEntityDtos, err := kubeProbe.ParseService(api.NamespaceAll, labels.Everything())
if err != nil {
// TODO, should here still send out msg to server? Or set errorDTO?
glog.Errorf("Error parsing services: %s. Will return.", err)
return
}
entityDtos := nodeEntityDtos
entityDtos = append(entityDtos, podEntityDtos...)
entityDtos = append(entityDtos, appEntityDtos...)
entityDtos = append(entityDtos, serviceEntityDtos...)
discoveryResponse := &comm.DiscoveryResponse{
EntityDTO: entityDtos,
}
// 3. Build Client message
clientMsg := comm.NewClientMessageBuilder(messageID).SetDiscoveryResponse(discoveryResponse).Create()
handler.wsComm.SendClientMessage(clientMsg)
}
func (handler *KubernetesServerMessageHandler) keepDiscoverAlive(messageID int32) {
//
glog.V(3).Infof("Keep Alive")
keepAliveMsg := &comm.KeepAlive{}
clientMsg := comm.NewClientMessageBuilder(messageID).SetKeepAlive(keepAliveMsg).Create()
handler.wsComm.SendClientMessage(clientMsg)
}
// Send action response to vmt server.
func (vmtcomm *VMTCommunicator) SendActionReponse(state sdk.ActionResponseState, progress, messageID int32, description string) {
// 1. build response
response := &comm.ActionResponse{
ActionResponseState: &state,
Progress: &progress,
ResponseDescription: &description,
}
// 2. built action result.
result := &comm.ActionResult{
Response: response,
}
// 3. Build Client message
clientMsg := comm.NewClientMessageBuilder(messageID).SetActionResponse(result).Create()
vmtcomm.wsComm.SendClientMessage(clientMsg)
}
// If server sends a validation request, validate the request.
// TODO, for now k8s validate all the request. aka, no matter what usr/passwd is provided, always pass validation.
// The correct bahavior is to set ErrorDTO when validation fails.
func (handler *KubernetesServerMessageHandler) Validate(serverMsg *comm.MediationServerMessage) {
//Always send Validated for now
glog.V(3).Infof("Kubernetes validation request from Server")
// 1. Get message ID.
messageID := serverMsg.GetMessageID()
// 2. Build validationResponse.
validationResponse := new(comm.ValidationResponse)
// 3. Create client message with ClientMessageBuilder.
clientMsg := comm.NewClientMessageBuilder(messageID).SetValidationResponse(validationResponse).Create()
handler.wsComm.SendClientMessage(clientMsg)
// TODO: Need to sleep some time, waiting validated. Or we should add reponse msg from server.
time.Sleep(100 * time.Millisecond)
glog.V(3).Infof("Discovery Target after validation")
handler.DiscoverTarget()
}