public static void Save(string path, IEnumerable <ConnectionEntry> list)
{
var computers = new List <ComputerInfo>();
var credentials = new List <CredentialsInfo>();
var webServices = new List <WebServiceInfo>();
var usedCredentials = new Dictionary <CredentialsInfo, int>();
var usedWebServices = new Dictionary <WebServiceInfo, int>();
foreach (var item in list)
{
var cred = new CredentialsInfo()
{
userName = item.UserName
};
var ws = new WebServiceInfo()
{
url = item.WebServiceURL
};
if (!usedCredentials.ContainsKey(cred))
{
credentials.Add(cred);
usedCredentials.Add(cred, usedCredentials.Count);
}
if (!usedWebServices.ContainsKey(ws))
{
webServices.Add(ws);
usedWebServices.Add(ws, usedWebServices.Count);
}
var comp = new ComputerInfo()
{
displayName = item.Description,
hostName = item.HostName,
authentication = item.UseCredSSP ? 4 : 0,
executionPolicy = item.ExecutionPolicy,
group = item.GroupName,
startupScript = item.StartupScript,
showAvailability = item.ShowAvailability,
credentialsIndex = usedCredentials[cred],
webServiceIndex = usedWebServices[ws]
};
computers.Add(comp);
}
var data = new WinRMXFileStruct()
{
version = "1.9", // compatible version
computers = computers,
credentials = credentials,
webServices = webServices
};
var plist = JsonConvert.DeserializeObject <Dictionary <string, object> >(JsonConvert.SerializeObject(data));
File.WriteAllBytes(path, Compress(Encoding.UTF8.GetBytes(Plist.writeXml(plist))));
}
/// <summary>
/// Gets the <see cref="WebServiceInfo"/> from the specified <paramref name="type"/> if it has the <see cref="WebServiceAttribute"/>
/// </summary>
/// <param name="type">
/// The type which should have the <see cref="WebServiceInfo"/>
/// </param>
/// <returns>
/// the <see cref="WebServiceInfo"/> from the specified <paramref name="type"/> if it has the <see cref="WebServiceAttribute"/> ; otherwise null
/// </returns>
private static WebServiceInfo GetEndpoint(Type type)
{
var attributes = type.GetCustomAttributes(true);
// ASMX
var webServiceAttribute = attributes.OfType <WebServiceAttribute>().FirstOrDefault();
if (webServiceAttribute != null)
{
var info = new WebServiceInfo {
Name = type.Name + ".asmx", Namespace = webServiceAttribute.Namespace
};
return(info);
}
// WCF
var serviceContractAttribute = attributes.OfType <ServiceContractAttribute>().FirstOrDefault();
if (serviceContractAttribute != null)
{
return(new WebServiceInfo {
Name = serviceContractAttribute.Name, Namespace = serviceContractAttribute.Namespace
});
}
return(null);
}
private void SwapWebservices(List <WebServiceInfo> webservices, int index1, int index2)
{
WebServiceInfo temp = webservices[index1];
webservices[index1] = webservices[index2];
webservices[index2] = temp;
}
public Object Clone()
{
WebServiceInfo tmpObj = new WebServiceInfo("", "");
tmpObj.WebService_ID = this.WebService_ID;
tmpObj.WebService_Name = this.WebService_Name;
tmpObj._webService_URL = this._webService_URL;
tmpObj.WebService_UserName = this.WebService_UserName;
tmpObj.WebService_Password = this.WebService_Password;
tmpObj.WebService_Crypted = this.WebService_Crypted;
return(tmpObj);
}
public CommonConst.Loading_Status getWebServices(XmlDocument WebServiceURLs)
{
try
{
WebServiceInfo tmpWs;
System.Xml.XmlDocument tmpDoc = WebServiceURLs;
XmlNodeList listNode = tmpDoc.SelectNodes("//WebService");
if (listNode == null)
{
return(CommonConst.Loading_Status.SDMX_WEBSERVICE_NOT_PRESENT);
}
if (listNode.Count == 0)
{
return(CommonConst.Loading_Status.SDMX_WEBSERVICE_NOT_PRESENT);
}
_WebServices = new List <WebServiceInfo>();
foreach (XmlNode nd in listNode)
{
tmpWs = new WebServiceInfo(nd.SelectSingleNode("Name").InnerText, nd.SelectSingleNode("Url").InnerText);
tmpWs.WebService_ID = int.Parse(nd.SelectSingleNode("ID").InnerText);
tmpWs.WebService_Description = nd.SelectSingleNode("Description").InnerText;
tmpWs.WebService_UserName = nd.SelectSingleNode("UserName").InnerText;
tmpWs.WebService_Password = nd.SelectSingleNode("Password").InnerText;
if (nd.SelectSingleNode("Crypted") != null)
{
tmpWs.WebService_Crypted = nd.SelectSingleNode("Crypted").InnerText == "true" ? true : false;
}
else
{
return(CommonConst.Loading_Status.OBSOLETE_VERSION);
}
if (nd.SelectSingleNode("ReturnDetail") != null)
{
tmpWs.WebService_ReturnDetail = nd.SelectSingleNode("ReturnDetail").InnerText == WebServiceInfo.RETURN_DETAIL_IMPLEMENTATION.Full.ToString() ? WebServiceInfo.RETURN_DETAIL_IMPLEMENTATION.Full : WebServiceInfo.RETURN_DETAIL_IMPLEMENTATION.CompleteStub;
}
_WebServices.Add(tmpWs);
}
return(CommonConst.Loading_Status.SDMX_WEBSERVICE_LOADED);
}
catch (Exception ex)
{
throw new Exception("Error, [Common.CommonItem.LoadSettings] " + ex.Message);
}
}
public void AddMember(WebService ws)
{
WebServiceInfo wsInfo = new WebServiceInfo();
wsInfo.ActivenessFactor = 0;
wsInfo.NegativeFeedbacks = 0;
wsInfo.NumberOfAcceptedTasks = 0;
wsInfo.NumberOfOfferedTasks = 0;
wsInfo.NumberOfTasksDone = 0;
wsInfo.PositiveFeedbacks = 0;
wsInfo.Webservice = ws;
this.members.Add(wsInfo);
}
private XmlDocument setXmlDocWebServices(WebServiceInfo IntWs, string XmlStartElementWS)
{
XmlTextWriter wr = null;
try
{
XmlDocument xmlDoc = new XmlDocument();
System.IO.MemoryStream ms = new System.IO.MemoryStream();
wr = new XmlTextWriter(ms, System.Text.Encoding.UTF8);
_interactionWebService = IntWs;
wr.WriteStartDocument();
wr.WriteStartElement(XmlStartElementWS);
wr.WriteStartElement("WebService");
wr.WriteElementString("ID", IntWs.WebService_ID.ToString());
wr.WriteElementString("Name", IntWs.WebService_Name);
wr.WriteElementString("Description", IntWs.WebService_Description);
wr.WriteElementString("Url", IntWs.WebService_public_URL);
wr.WriteElementString("UserName", IntWs.WebService_UserName);
wr.WriteElementString("Password", IntWs.WebService_Password);
wr.WriteElementString("Crypted", IntWs.WebService_Crypted == true ? "true" : "false");
wr.WriteElementString("ReturnDetail", IntWs.WebService_ReturnDetail.ToString());
wr.WriteEndElement(); //WebService
wr.WriteEndElement(); //</"XmlStartElementWS">
wr.WriteEndDocument();
wr.Flush();
string xmlText = System.Text.Encoding.UTF8.GetString(ms.ToArray());
xmlDoc.LoadXml(xmlText.Substring(1));
return(xmlDoc);
}
catch (Exception ex)
{
throw new Exception("Error, [GetDataDLL.Services.Config.ApplicationSettings.LoadSettings] " + ex.Message);
}
finally
{
if (wr != null)
{
wr.Close();
}
}
}
/// <summary>
/// Build the endpoint array
/// </summary>
/// <returns>
/// The endpoint info array
/// </returns>
private static WebServiceInfo[] BuildEndpoints()
{
var endpointInfos = new WebServiceInfo[_types.Length];
for (int i = 0; i < _types.Length; i++)
{
endpointInfos[i] = GetEndpoint(_types[i]);
if (endpointInfos[i] != null)
{
endpointInfos[i].SchemaPath = _schemas[i];
endpointInfos[i].Description = _names[i];
}
}
return(endpointInfos);
}
public int getWebServiceIdBy_Url_Name(string URL, string WSName)
{
try
{
WebServiceInfo tmpWS = _WebServices.Find(delegate(WebServiceInfo wsInfo)
{ return(wsInfo.WebService_Name == WSName && wsInfo.WebService_public_URL == URL); });
if (tmpWS != null)
{
return(tmpWS.WebService_ID);
}
return(-1);
}
catch (Exception ex)
{
throw new Exception("Error, [GetDataDLL.Services.Config.ApplicationSettings.getWebServiceIdBy_Url_Name] " + ex.Message);
}
}
public SoapClient(WebServiceInfo webServiceInfo, string methodName)
{
this.AddParameters();
this.Url = webServiceInfo.ServiceUrls.First();
var methodInfo = webServiceInfo.WebMethods.First(x => x.Name == methodName);
this.MethodName = methodInfo.Name;
this.SoapAction = methodInfo.Action;
this.Namespace = methodInfo.TargetNamespace;
foreach (Services.Parameter inputParam in methodInfo.InputParameters)
{
this.DataMappings.AddOrUpdate(new DataMapping()
{
Name = inputParam.Name
});
}
}
protected override IEnumerable <CommandParameters> Execute(IEnumerable <CommandParameters> inParametersList)
{
foreach (var inParameters in inParametersList)
{
//inParameters = GetCurrentInParameters();
string serviceUrl = inParameters.GetValue <string>("Url");
string nameSpace = inParameters.GetValue <string>("Namespace");
string soapAction = inParameters.GetValue <string>("SoapAction");
string methodName = inParameters.GetValue <string>("MethodName");
string wsdlUrl = inParameters.GetValue <string>("Wsdl");
if (!string.IsNullOrEmpty(wsdlUrl))
{
var webServiceInfo = new WebServiceInfo(wsdlUrl);
serviceUrl = webServiceInfo.ServiceUrls.First();
var methodInfo = webServiceInfo.WebMethods.First(x => x.Name == methodName);
methodName = methodInfo.Name;
soapAction = methodInfo.Action;
nameSpace = methodInfo.TargetNamespace;
if (!this.DataMappings.Any())
{
foreach (Services.Parameter inputParam in methodInfo.InputParameters)
{
this.DataMappings.AddOrUpdate(new DataMapping()
{
Name = inputParam.Name
});
}
}
}
string encodingName = inParameters.GetValueOrDefault <string>("EncodingName", "utf-8");
string passWord = inParameters.GetValue <string>("Password");
string user = inParameters.GetValue <string>("User");
foreach (var data in this.ReadData(serviceUrl, methodName, nameSpace, soapAction, encodingName, inParameters.ToDictionary()))
{
var outParameters = this.GetCurrentOutParameters();
outParameters.SetOrAddValue("Data", data);
yield return(outParameters);
}
}
}
private CommonConst.Loading_Status getWebService(XmlDocument WebServiceURLs, ref WebServiceInfo wsInfo)
{
try
{
System.Xml.XmlDocument tmpDoc = WebServiceURLs;
if (tmpDoc == null)
{
return(CommonConst.Loading_Status.SDMX_WEBSERVICE_NOT_PRESENT);
}
XmlNode nd = tmpDoc.SelectSingleNode("//WebService");
if (nd == null)
{
return(CommonConst.Loading_Status.SDMX_WEBSERVICE_NOT_PRESENT);
}
wsInfo = new WebServiceInfo();
wsInfo = new WebServiceInfo(nd.SelectSingleNode("Name").InnerText, nd.SelectSingleNode("Url").InnerText);
wsInfo.WebService_ID = int.Parse(nd.SelectSingleNode("ID").InnerText);
wsInfo.WebService_Description = nd.SelectSingleNode("Description").InnerText;
wsInfo.WebService_UserName = nd.SelectSingleNode("UserName").InnerText;
wsInfo.WebService_Password = nd.SelectSingleNode("Password").InnerText;
wsInfo.WebService_Crypted = nd.SelectSingleNode("Crypted").InnerText == "true" ? true : false;
if (nd.SelectSingleNode("ReturnDetail") != null)
{
wsInfo.WebService_ReturnDetail = nd.SelectSingleNode("ReturnDetail").InnerText == WebServiceInfo.RETURN_DETAIL_IMPLEMENTATION.Full.ToString() ? WebServiceInfo.RETURN_DETAIL_IMPLEMENTATION.Full : WebServiceInfo.RETURN_DETAIL_IMPLEMENTATION.CompleteStub;
}
return(CommonConst.Loading_Status.LOADED);
}
catch (Exception ex)
{
throw new Exception("Error, [GetDataDLL.Services.Config.ApplicationSettings.LoadSettings] " + ex.Message);
}
}
public void AddMember(WebService ws)
{
WebServiceInfo wsInfo = new WebServiceInfo();
wsInfo.ActivenessFactor = 0;
wsInfo.NegativeFeedbacks = 0;
wsInfo.NumberOfAcceptedTasks = 0;
wsInfo.NumberOfOfferedTasks = 0;
wsInfo.NumberOfTasksDone = 0;
wsInfo.PositiveFeedbacks = 0;
wsInfo.Webservice = ws;
this.members.Add(wsInfo);
}
public XmlDocument setXmlDocValidationWebServices(WebServiceInfo IntWs)
{
return(setXmlDocWebServices(IntWs, "ValidationWebService"));
}
public XmlDocument setXmlDocInteractionWebServices(WebServiceInfo IntWs)
{
return(setXmlDocWebServices(IntWs, "InteractionWebService"));
}
/// <summary>
/// Task allocation
/// </summary>
public void OfferTaskToWebservice()
{
// UpdateMemberlist();
List <WebServiceInfo> competitiveMembers = members.FindAll(delegate(WebServiceInfo wsInfo) { return(wsInfo.Webservice.ReadyToCompete == true); });
SortTaskPool(taskPool, "QoS");
if (competitiveMembers.Count < 1)
{
Environment.outputLog.AppendText("There are no competitive web services.\n");
return;
}
Random rnd = new Random(DateTime.Now.Millisecond);
//int numberOfTasksToBeDone = rnd.Next(1, competitiveMembers.Count);
int numberOfTasksToBeDone = rnd.Next(1, Constants.MaxNumberOfTasksPerRun);
int numberOfAcceptingMembers = (int)Math.Ceiling(Constants.AcceptanceProbability * competitiveMembers.Count);
int numberOfRejectingMembers = competitiveMembers.Count - numberOfAcceptingMembers;
Environment.outputLog.AppendText("competitive Members: " + competitiveMembers.Count + "\n");
Environment.outputLog.AppendText("Number of Tasks to be done: " + numberOfTasksToBeDone + "\n");
Environment.outputLog.AppendText("Number of Accepting Members: " + numberOfAcceptingMembers + "\n");
List <Task> notAssignedTasks = taskPool.FindAll(delegate(Task task) { return(!(task.Assigned)); });
int numberOfTasksToBeAssigned = Math.Min(numberOfAcceptingMembers, numberOfTasksToBeDone);
numberOfTasksToBeAssigned = Math.Min(numberOfTasksToBeAssigned, notAssignedTasks.Count);
Environment.outputLog.AppendText("Number of Tasks to be assigned: " + numberOfTasksToBeAssigned + "\n");
if (notAssignedTasks.Count < 1)
{
Environment.outputLog.AppendText("There are no tasks left.\n");
return;
}
Environment.outputLog.AppendText("Number of Tasks Left: " + notAssignedTasks.Count + "\n");
Environment.outputLog.AppendText("Web Services ");
int k = 0;
// Randomly selects among competitive web services
int[] indices = new int[numberOfTasksToBeAssigned];
List <int> competitiveIndices = new List <int>(competitiveMembers.Count);
for (int i = 0; i < competitiveMembers.Count; i++)
{
competitiveIndices.Add(competitiveMembers[i].Webservice.Id);
}
for (int i = 0; i < numberOfTasksToBeAssigned; i++)
{
int index = rnd.Next(0, competitiveIndices.Count);
indices[i] = competitiveIndices[index];
competitiveIndices.RemoveAt(index);
}
// Assigns tasks
for (int i = 0; i < numberOfTasksToBeAssigned; i++)
{
notAssignedTasks[i].Assigned = true;
WebServiceInfo wsInfo = competitiveMembers.Find(delegate(WebServiceInfo winfo) { return(winfo.Webservice.Id == indices[i]); });
if (wsInfo.Webservice.Reputation >= Constants.ReputationThreshold)
{
wsInfo.NumberOfOfferedTasks++;
wsInfo.CurrentIfOfferedTask = true;
wsInfo.NumberOfAcceptedTasks++;
wsInfo.CurrentIfAcceptedTask = true;
wsInfo.CurrentAssignedTask = notAssignedTasks[i];
Environment.outputLog.AppendText(" " + wsInfo.Webservice.Id + " ");
k = i;
}
}
Environment.outputLog.AppendText(" got the job\n");
if (numberOfAcceptingMembers < numberOfTasksToBeAssigned)
{
int numberOfRemainedTasks = Math.Max(numberOfAcceptingMembers, numberOfTasksToBeDone) - numberOfTasksToBeAssigned;
int[] refusedIndices = new int[numberOfRemainedTasks];
for (int i = 0; i < numberOfRemainedTasks; i++)
{
int index = rnd.Next(0, competitiveIndices.Count);
refusedIndices[i] = competitiveIndices[index];
competitiveIndices.RemoveAt(index);
}
for (int j = k; j < numberOfRemainedTasks; j++)
{
WebServiceInfo wsInfo = competitiveMembers.Find(delegate(WebServiceInfo winfo) { return(winfo.Webservice.Id == refusedIndices[j]); });
wsInfo.NumberOfOfferedTasks++;
wsInfo.CurrentIfOfferedTask = true;
wsInfo.CurrentIfAcceptedTask = false;
Environment.outputLog.AppendText(" " + wsInfo.Webservice.Id + " ");
}
Environment.outputLog.AppendText(" refused the offer\n");
}
// Check for the case that number of tasks are greater than number of accepting web services
}
/// <summary>
/// Task allocation
/// </summary>
public void OfferTaskToWebservice()
{
// UpdateMemberlist();
List <WebServiceInfo> competitiveMembers = members.FindAll(delegate(WebServiceInfo wsInfo) { return(wsInfo.Webservice.ReadyToCompete == true); });
Environment.outputLog.AppendText("Sorting Tasks: " + taskPool.Count);
SortTaskPool(taskPool, "QoS");
if (competitiveMembers.Count < 1)
{
Environment.outputLog.AppendText("There are no competitive web services.\n");
return;
}
Random rnd = new Random(DateTime.Now.Millisecond);
//int numberOfTasksToBeDone = rnd.Next(1, competitiveMembers.Count);
int numberOfTasksToBeDone = rnd.Next(Constants.MinNumberOfTasksPerRun, Constants.MaxNumberOfTasksPerRun);
int numberOfAcceptingMembers = (int)Math.Ceiling(Constants.AcceptanceProbability * competitiveMembers.Count);
int numberOfRejectingMembers = competitiveMembers.Count - numberOfAcceptingMembers;
Environment.outputLog.AppendText("competitive Members: " + competitiveMembers.Count + "\n");
Environment.outputLog.AppendText("Number of Tasks to be done: " + numberOfTasksToBeDone + "\n");
Environment.outputLog.AppendText("Number of Accepting Members: " + numberOfAcceptingMembers + "\n");
List <Task> notAssignedTasks = taskPool.FindAll(delegate(Task task) { return(!(task.Assigned)); });
int numberOfTasksToBeAssigned = Math.Min(numberOfAcceptingMembers, numberOfTasksToBeDone);
numberOfTasksToBeAssigned = Math.Min(numberOfTasksToBeAssigned, notAssignedTasks.Count);
Environment.outputLog.AppendText("Number of Tasks to be assigned: " + numberOfTasksToBeAssigned + "\n");
if (notAssignedTasks.Count < 1)
{
Environment.outputLog.AppendText("There are no tasks left.\n");
return;
}
Environment.outputLog.AppendText("Number of Tasks Left: " + notAssignedTasks.Count + "\n");
Environment.outputLog.AppendText("Web Services ");
int k = 0;
// Randomly selects among competitive web services
int[] indices = new int[numberOfTasksToBeAssigned];
List <int> competitiveIndices = new List <int>(competitiveMembers.Count);
for (int i = 0; i < competitiveMembers.Count; i++)
{
competitiveIndices.Add(competitiveMembers[i].Webservice.Id);
}
for (int i = 0; i < numberOfTasksToBeAssigned; i++)
{
int index = rnd.Next(0, competitiveIndices.Count);
indices[i] = competitiveIndices[index];
competitiveIndices.RemoveAt(index);
}
// Assigns tasks
for (int i = 0; i < numberOfTasksToBeAssigned; i++)
{
// Finding highest growsthfactor or reputation that has task qos
double maxGrowthFactor = 0;
int maxGrowthFactorIndex = -1;
for (int l = 0; l < competitiveMembers.Count; l++)
{
if ((competitiveMembers[l].CurrentIfAcceptedTask == false) &&
(competitiveMembers[l].Webservice.QoS > notAssignedTasks[i].QoS + 0.01) &&
competitiveMembers[l].Webservice.GrowthFactor > maxGrowthFactor)
{
maxGrowthFactor = competitiveMembers[l].Webservice.GrowthFactor;
maxGrowthFactorIndex = l;
}
}
if (competitiveMembers[0].Webservice.Type == Constants.WebserviceType.JustCompetitive || competitiveMembers[0].Webservice.Type == Constants.WebserviceType.Random)
{
maxGrowthFactorIndex = 1; //Somthing Irrevelant
}
if (maxGrowthFactorIndex == -1)
{ // No sebservice has the QoS needed for the task so we are dismissing the task i
notAssignedTasks[i].Assigned = true;
}
else
{
notAssignedTasks[i].Assigned = true;
WebServiceInfo wsInfo;
if (competitiveMembers[0].Webservice.Type == Constants.WebserviceType.JustCompetitive || competitiveMembers[0].Webservice.Type == Constants.WebserviceType.Random)
{
wsInfo = competitiveMembers.Find(delegate(WebServiceInfo winfo) { return(winfo.Webservice.Id == indices[i]); });
}
else
{
wsInfo = competitiveMembers[maxGrowthFactorIndex];
}
if (wsInfo.Webservice.Reputation >= Constants.ReputationThreshold)
{
wsInfo.NumberOfOfferedTasks++;
wsInfo.CurrentIfOfferedTask = true;
wsInfo.NumberOfAcceptedTasks++;
wsInfo.CurrentIfAcceptedTask = true;
wsInfo.CurrentAssignedTask = notAssignedTasks[i];
Environment.outputLog.AppendText(" " + wsInfo.Webservice.Id + " ");
k = i;
}
}
}
Environment.outputLog.AppendText(" got the job\n");
if (numberOfAcceptingMembers < numberOfTasksToBeAssigned)
{
int numberOfRemainedTasks = Math.Max(numberOfAcceptingMembers, numberOfTasksToBeDone) - numberOfTasksToBeAssigned;
int[] refusedIndices = new int[numberOfRemainedTasks];
for (int i = 0; i < numberOfRemainedTasks; i++)
{
int index = rnd.Next(0, competitiveIndices.Count);
refusedIndices[i] = competitiveIndices[index];
competitiveIndices.RemoveAt(index);
}
for (int j = k; j < numberOfRemainedTasks; j++)
{
WebServiceInfo wsInfo = competitiveMembers.Find(delegate(WebServiceInfo winfo) { return(winfo.Webservice.Id == refusedIndices[j]); });
wsInfo.NumberOfOfferedTasks++;
wsInfo.CurrentIfOfferedTask = true;
wsInfo.CurrentIfAcceptedTask = false;
Environment.outputLog.AppendText(" " + wsInfo.Webservice.Id + " ");
}
Environment.outputLog.AppendText(" refused the offer\n");
}
// Check for the case that number of tasks are greater than number of accepting web services
}
