/// <summary>
/// Helper method to copy data from an <see cref="EndpointData"/>
/// to an <see cref="EndpointInfo"/> instance.
/// </summary>
/// <param name="info">The full data instance.</param>
/// <param name="data">The data instance.</param>
public static void CopyFrom(this EndpointInfo info, EndpointData data)
{
info.Link = data?.Link;
info.Name = data?.Name;
info.RoomId = data?.Room;
info.Tags = data?.Tags;
}
private void lvEndpoints_SelectedIndexChanged(object sender, EventArgs e)
{
if (lvEndpoints.SelectedItems.Count > 1)
{
if (!m_RestServerRunning)
{
toolStripButtonRemoveEndpoint.Enabled = true;
}
}
else if (lvEndpoints.SelectedItems.Count == 1)
{
ListViewItem thisItem = lvEndpoints.SelectedItems[0];
EndpointData thisData = thisItem.Tag as EndpointData;
if (thisData != null)
{
ShowEndpointTab(thisItem, thisData, false);
}
if (!m_RestServerRunning)
{
toolStripButtonRemoveEndpoint.Enabled = true;
}
}
else
{
toolStripButtonRemoveEndpoint.Enabled = false;
}
}
private void toolStripButtonRemoveEndpoint_Click(object sender, EventArgs e)
{
if (lvEndpoints.SelectedItems.Count > 1)
{
for (int i = 0; i < lvEndpoints.SelectedItems.Count; i++)
{
ListViewItem thisItem = lvEndpoints.SelectedItems[i];
EndpointData thisData = thisItem.Tag as EndpointData;
if (MessageBox.Show($"Do you want to remove endpoint {thisData.Name}?", "Remove Endpoint", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
if (thisData != null)
{
m_RestServerData.RemoveEndpoint(thisData);
}
lvEndpoints.Items.Remove(thisItem);
}
}
}
else if (lvEndpoints.SelectedItems.Count == 1)
{
ListViewItem thisItem = lvEndpoints.SelectedItems[0];
EndpointData thisData = thisItem.Tag as EndpointData;
if (MessageBox.Show($"Do you want to remove endpoint {thisData.Name}?", "Remove Endpoint", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
if (thisData != null)
{
m_RestServerData.RemoveEndpoint(thisData);
}
lvEndpoints.Items.Remove(thisItem);
}
}
}
public MockEndpointTabPage(EndpointData data) : base(data.Name)
{
m_EndpointData = data;
m_MockEndpointUserControl = new MockEndpoint(data);
this.Controls.Add(m_MockEndpointUserControl);
m_MockEndpointUserControl.Dock = DockStyle.Fill;
}
// Constructor used for ice2 parsing.
private WSEndpoint(
EndpointData data,
Dictionary <string, string> options,
Communicator communicator,
bool oaEndpoint)
: base(data, options, communicator, oaEndpoint)
{
}
internal static TypeData GetEndpointResponse(EndpointData endpoint)
{
var response = GetMemberResponse(endpoint.Method);
if (response == null && endpoint.HttpMethod == HttpMethod.Get)
{
throw new EndpointException($"HTTP GET must have a return type; add {nameof(ResponseAttribute)}.", endpoint.Method);
}
return(response);
}
/// <summary>
/// Helper method to convert an <see cref="EndpointData"/> instance
/// to an <see cref="EndpointInfo"/> instance.
/// </summary>
/// <param name="data">The data instance.</param>
/// <returns>The converted data.</returns>
public static EndpointInfo ToEndpointInfo(this EndpointData data)
{
return(new EndpointInfo()
{
Uuid = data?.Uuid,
Link = data?.Link,
Name = data?.Name,
RoomId = data?.Room,
Tags = data?.Tags
});
}
private void toolStripButtonAddEndpoint_Click(object sender, EventArgs e)
{
using (AddMockEndpointDialog AMED = new AddMockEndpointDialog())
{
if (AMED.ShowDialog() == DialogResult.OK)
{
EndpointData newData = new EndpointData(AMED.MockEndpointName);
m_RestServerData.AddEndpoint(newData);
}
}
}
// Constructor for ice1 parsing
private WSEndpoint(
EndpointData data,
TimeSpan timeout,
bool compress,
Dictionary <string, string?> options,
Communicator communicator,
bool oaEndpoint,
string endpointString)
: base(data, timeout, compress, options, communicator, oaEndpoint, endpointString)
{
}
private void lvEndpoints_DoubleClick(object sender, EventArgs e)
{
if (lvEndpoints.SelectedItems.Count == 1)
{
ListViewItem thisItem = lvEndpoints.SelectedItems[0];
EndpointData thisData = thisItem.Tag as EndpointData;
if (thisData != null)
{
ShowEndpointTab(thisItem, thisData, true);
}
}
}
internal static new WSEndpoint CreateIce2Endpoint(EndpointData data, Communicator communicator)
{
Debug.Assert(data.Transport == Transport.WS || data.Transport == Transport.WSS); // TODO: remove WSS
string[] options = data.Options;
if (options.Length > 1)
{
// Drop extra options since we don't understand them.
options = new string[] { options[0] };
}
return(new WSEndpoint(new EndpointData(data.Transport, data.Host, data.Port, options), communicator));
}
private void AddEndpoint(EndpointData data)
{
ListViewItem newMockEndpointItem = new ListViewItem(data.Name);
MockEndpointTabPage newMockEndpointTabPage = new MockEndpointTabPage(data);
newMockEndpointItem.Tag = data;
lvEndpoints.Items.Add(newMockEndpointItem);
newMockEndpointItem.Text = $"{data.Name}({data.HttpEndpointAddress} )";
newMockEndpointItem.Text = $"{data.Name}({data.HttpEndpointAddress})";
newMockEndpointTabPage.Tag = newMockEndpointItem;
tabControlEndpoints.TabPages.Add(newMockEndpointTabPage);
}
internal static IEnumerable <RequestParameterData> GetEndpointParameters(EndpointData endpoint)
{
foreach (var parameter in endpoint.Method.Parameters)
{
if (!parameter.TryGetAttribute <IBindingSourceMetadata>(out var bindingSourceMetadata) || bindingSourceMetadata.BindingSource == BindingSource.Header)
{
continue;
}
var name = parameter.TryGetAttribute <IModelNameProvider>(out var modelNameProvider) && !string.IsNullOrEmpty(modelNameProvider.Name) ? modelNameProvider.Name : parameter.Name;
var defaultValue = parameter.ParameterType.Implements(RequestType) && parameter.ParameterType.TryCreate <IRequest>(null, out var response)
? response.GetDefaultValue()
: parameter.IsOptional
? parameter.DefaultValue
: null;
yield return(new RequestParameterData(name, defaultValue, defaultValue != null, bindingSourceMetadata.BindingSource, parameter));
}
}
public JavaVersion(string folder)
{
Name = Path.GetFileName(folder);
LauncherJsonPath = Path.Combine(folder, Name + ".json");
var json = JsonObject.Parse(File.ReadAllText(LauncherJsonPath));
ReleaseTime = DateTime.Parse(json["releaseTime"].ToString(), CultureInfo.InvariantCulture, DateTimeStyles.None);
Client = new(
"client",
Path.Combine(folder, Name + ".jar"),
(string)json["downloads"]?["client_mappings"]?["url"]
);
Server = new(
"server",
null,
(string)json["downloads"]?["server_mappings"]?["url"]
);
ServerJarURL = (string)json["downloads"]?["server"]?["url"];
AssetsURL = (string)json["assetIndex"]?["url"];
}
internal static IEnumerable <HttpStatusCode> GetEndpointStatusCodes(EndpointData endpoint)
{
var statusCodes = new HashSet <HttpStatusCode>();
foreach (var statusCode in GetMemberStatusCodes(endpoint.Method))
{
statusCodes.Add(statusCode);
}
foreach (var statusCode in GetStatusCodesFromInstructions(endpoint.Method.Instructions))
{
statusCodes.Add(statusCode);
}
if (statusCodes.Count == 0)
{
throw new EndpointException("No HTTP status codes were found.", endpoint.Method);
}
return(statusCodes);
}
//- @Register -//
public override void Register()
{
String blogGuid = ParameterMap.PeekSafely("blogGuid");
if (String.IsNullOrEmpty(blogGuid))
{
throw new System.Configuration.ConfigurationErrorsException("blogPage parameter is required for the Blog component.");
}
//+ factory
AddFactory(FactoryData.Create("Minima.Web.Processing.HandlerFactory, Minima.Web"));
AddFactory(FactoryData.Create("Minima.Web.Processing.ProcessorFactory, Minima.Web"));
//+ processor
AddProcessor(ProcessorData.Create <ProcessorData>("__$Minima$InitProcessor", new Object[] { blogGuid }));
//+ handler
AddEndpoint(EndpointData.Create(SelectorType.EndsWith, "/rsd.xml", "__$Minima$BlogDiscovery"));
AddEndpoint(EndpointData.Create(SelectorType.EndsWith, "/wlwmanifest.xml", "__$Minima$WindowsLiveWriterManifest"));
AddEndpoint(EndpointData.Create(SelectorType.EndsWith, "/blogmap.xml", "__$Minima$SiteMap"));
AddEndpoint(EndpointData.Create(SelectorType.Contains, "/xml-rpc", "__$Minima$MetaWeblogApi"));
AddEndpoint(EndpointData.Create(SelectorType.Contains, "/xml-rpc/", "__$Minima$MetaWeblogApi"));
AddEndpoint(EndpointData.Create(SelectorType.Contains, "/imagestore", "__$Minima$Image"));
}
internal static new WSEndpoint ParseIce2Endpoint(
Transport transport,
string host,
ushort port,
Dictionary <string, string> options,
Communicator communicator,
bool oaEndpoint,
string _)
{
Debug.Assert(transport == Transport.WS || transport == Transport.WSS);
string?resource = null;
if (options.TryGetValue("resource", out string?value))
{
// The resource value (as supplied in a URI string) must be percent-escaped with '/' separators
// We keep it as-is, and will marshal it as-is.
resource = value;
options.Remove("resource");
}
else if (options.TryGetValue("option", out value))
{
// We are parsing a ice+universal endpoint
if (value.Contains(','))
{
throw new FormatException("an ice+ws endpoint accepts at most one marshaled option (resource)");
}
// Each option of a universal endpoint needs to be unescaped
resource = Uri.UnescapeDataString(value);
options.Remove("option");
}
var data = new EndpointData(transport,
host,
port,
resource == null ? Array.Empty <string>() : new string[] { resource });
return(new WSEndpoint(data, options, communicator, oaEndpoint));
}
private void ShowEndpointTab(ListViewItem item, EndpointData data, bool openTab)
{
MockEndpointTabPage thisTagPage = tabControlEndpoints.TabPages.Cast <MockEndpointTabPage>().Where(c => c.EndpointData == data).FirstOrDefault();
if (!m_RestServerData.Endpoints.Contains(data))
{
m_RestServerData.AddEndpoint(data);
}
else if (thisTagPage != null)
{
tabControlEndpoints.SelectedTab = thisTagPage;
}
else if (openTab)
{
MockEndpointTabPage newMockEndpointTabPage = new MockEndpointTabPage(data);
item.Tag = data;
newMockEndpointTabPage.Tag = item;
tabControlEndpoints.TabPages.Add(newMockEndpointTabPage);
tabControlEndpoints.SelectedTab = newMockEndpointTabPage;
}
}
private HomeViewModel GetViewModel()
{
var model = new HomeViewModel();
List <string> hosts = GetHosts();
foreach (var host in hosts)
{
var endpointData = new EndpointData();
endpointData.Url = host;
var hostWithoutSlash = host.TrimEnd('/');
var hostParts = hostWithoutSlash.Split(":");
var portPart = hostParts.Last();
if (int.TryParse(portPart, out int portNumber))
{
endpointData.PortNumber = portNumber;
}
model.Endpoints.Add(endpointData);
}
return(model);
}
// Constructor for ice2 unmarshaling.
private WSEndpoint(EndpointData data, Communicator communicator)
: base(data, communicator)
{
}
// Constructor for ice1 unmarshaling
private WSEndpoint(EndpointData data, TimeSpan timeout, bool compress, Communicator communicator)
: base(data, timeout, compress, communicator)
{
}
// Constructor for ice2 unmarshaling.
internal WSEndpoint(EndpointData data, Communicator communicator)
: base(data, communicator)
{
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="xmlConfig"></param>
/// <param name="baseAddress"></param>
public RestEndpoint(EndpointData data, PatternData pattern, string baseAddress)
{
m_RestJobConfig = data;
m_Pattern = pattern;
m_BaseAddress = baseAddress;
m_Address = data.HttpEndpointAddress;//xmlConfig["endpoint_address", string.Empty].Trim();
if (m_Address == string.Empty)
{
throw new EndpointDataException(data,
"HttpEndpointAddress",
"endpoint address is required");
}
m_ContentType = DataEnums.GetDescriptorText(pattern.ResponseData.ContentType);//xmlConfig["content_type", string.Empty].Trim();
if (m_ContentType == string.Empty)
{
throw new EndpointDataException(data,
"ContentType",
"content type is required");
}
else
{
if (m_ContentType.ToLower() == "json")
{
m_ContentType = RestServer.MIME_TYPE_JSON;
}
if (m_ContentType.ToLower() == "xml")
{
m_ContentType = RestServer.MIME_TYPE_XML;
}
}
m_HttpMethod = DataEnums.GetDescriptorText(pattern.HttpMethod); //xmlConfig["http_method", string.Empty].Trim();
m_Timeout = -1; //xmlConfig["timeout", -1];
//XmlHelper restJob = xmlConfig.FindNodeHelper("rest_job");
//m_RestJobConfig = restJob;
//m_Assembly =
//restJob["job_assembly", String.Empty].Trim();
//Assembly endpointAssembly; // If 'session_assembly' attribute
// // found,
//if (m_Assembly.Length > 0)
//{
// // If assembly file does not contain a
// // path,
// if (m_Assembly.IndexOf(
// Path.DirectorySeparatorChar) < 0)
// {
// // Prepend path for current application
// m_Assembly = PlatformCore.AppBaseDirectory +
// m_Assembly;
// }
// try // Load assembly from specified file
// {
// endpointAssembly = Assembly.LoadFrom(
// m_Assembly);
// }
// catch (Exception innerException)
// {
// // Throw exception without logging it
// throw new XmlHelperException(innerException,
// restJob.AttributeSource("job_assembly"),
// "Exception loading assembly from file '" +
// m_Assembly + "': " +
// innerException.Message);
// }
//}
//else // Else 'session_assembly' attribute not
//{ // found
// // Get currently executing assembly
// endpointAssembly = Assembly.GetExecutingAssembly();
//}
//// Get session class
//m_Class =
// restJob["job_class", String.Empty].Trim();
//// If missing 'session_class'
//// attribute,
//if (m_Class.Length == 0)
//{
// // Throw exception without logging it
// throw new XmlHelperException(null,
// restJob.AttributeSource("job_class"), "Element <" +
// xmlConfig.Name + "> missing 'session_class' attribute");
//}
//// If session class full name does not
//// contain '.',
//if (m_Class.IndexOf('.') < 0)
//{
// // Prepend default path to class name
// m_Class =
// "Intelligrated.Common.CommLibrary." +
// m_Class;
//}
//// Get type for session class
//try
//{
// m_ClassType = endpointAssembly.GetType(
// m_Class);
//}
//catch (Exception innerException)
//{
// // Throw exception without logging it
// throw new XmlHelperException(innerException,
// restJob.AttributeSource("job_class"),
// "Exception getting class type for " + m_Class +
// ": " + innerException.Message);
//}
//// If class not found,
//if (m_ClassType == null)
//{
// // Throw exception without logging it
// throw new XmlHelperException(null,
// restJob.AttributeSource("job_class"),
// "Could not find class '" + m_Class +
// "' in assembly '" + endpointAssembly.FullName + "'");
//}
//m_Method = restJob["job_method", string.Empty].Trim();
//if (m_Method == string.Empty)
//{
// throw new XmlHelperException(null,
// restJob.AttributeSource("job_method"),
// "endpoint method is a required attribute");
//}
//if (m_ClassType.IsSubclassOf(typeof(RestJob)))
//{
// m_RestJobInstance = (RestJob)Activator.CreateInstance(m_ClassType);
//}
//else
//{
// throw new ArgumentException(string.Format("Class {0} doesn't inherit from RestJob", m_ClassType.FullName));
//}
////Check that method has no additional parameters
//if(ValidateMethod() == false)
//{
// throw new ArgumentException(string.Format("Method {0} has invalid parameters. UriArgs parameter must be of type NameValueCollection and payload parameter must be named payload, there can not be more than two parameters.", m_Method));
//}
}
public MockEndpoint(EndpointData data)
{
InitializeComponent();
m_EndpointData = data;
GradientToolStripRenderer GradientRenderer = new GradientToolStripRenderer(Color.FromArgb(195, 195, 195), Color.FromArgb(110, 110, 110));
GradientRenderer.RoundedEdges = false;
toolStripMain.Renderer = GradientRenderer;
comboBoxStatusCode.DataSource = DataEnums.GetEnumWrappers <HttpStatusCode>();
comboBoxStatusCode.DisplayMember = "Descriptor";
comboBoxStatusCode.ValueMember = "Value";
comboBoxHttpMethod.DataSource = DataEnums.GetEnumWrappers <HttpMethod>();
comboBoxHttpMethod.DisplayMember = "Descriptor";
comboBoxHttpMethod.ValueMember = "Value";
comboBoxContentType.DataSource = DataEnums.GetEnumWrappers <ContentType>();
comboBoxContentType.DisplayMember = "Descriptor";
comboBoxContentType.ValueMember = "Value";
txtResponseDelay.Enabled = false;
SetReponseEnables(false);
if (data.Patterns.Count() > 0)
{
foreach (PatternData pattern in data.Patterns)
{
AddPattern(pattern);
}
}
if (data.HttpEndpointAddress != string.Empty)
{
txtAddress.Text = data.HttpEndpointAddress;
lblListenerAddress.Text = m_EndpointData.Owner.ListenerAddress + data.HttpEndpointAddress;
}
else
{
lblListenerAddress.Text = m_EndpointData.Owner.ListenerAddress;
}
ProjectData.OnRestServerChanged += ProjectData_OnRestServerChanged;
ProjectData.RestServerManager.OnRestServerStarted += RestServerManager_OnRestServerStarted;
ProjectData.RestServerManager.OnRestServerStopped += RestServerManager_OnRestServerStopped;
m_EndpointData.OnPatternAdded += EndpointData_OnPatternAdded;
m_EndpointData.OnPatternRemoved += EndpointData_OnPatternRemoved;
m_EndpointData.OnPatternChanged += EndpointData_OnPatternChanged;
Restward.RestServer.RestServer thisRestServer = ProjectData.RestServerManager.RestServers.Where(c => c.RestServerData == data.Owner).FirstOrDefault();
if (thisRestServer != null)
{
m_RestServerRunning = thisRestServer.IsServerRunning;
if (m_RestServerRunning)
{
SetRestServerEnables(false);
}
}
}
internal static IReadOnlyList <RequestParameterData> GetEndpointHeaders(EndpointData endpoint)
{
return(JoinHeaders(endpoint.Controller.Headers, GetMemberHeaders(endpoint.Method), GetParameterHeaders(endpoint.Method.Parameters)).ToArray());
}
