HttpWebResponse Stage1(ServiceAction action, WebHeaderCollection headers, int retry, Stream stream)
{
if (fallback.OmitMan) {
return Stage1 (action, headers, retry, stream, CreateRequestWithoutMan, CreateRequestWithMan);
} else {
return Stage1 (action, headers, retry, stream, CreateRequestWithMan, CreateRequestWithoutMan);
}
}
HttpWebResponse Stage1(ServiceAction action, WebHeaderCollection headers, int retry, Stream stream,
RequestProvider requestProvider1, RequestProvider requestProvider2)
{
var response = Stage2 (requestProvider1, action, headers, retry, stream);
if (response.StatusCode == HttpStatusCode.MethodNotAllowed) {
response = Stage2 (requestProvider2, action, headers, retry, stream);
}
return response;
}
HttpWebResponse GetResponse(ServiceAction action, WebHeaderCollection headers,
int retry, Stream stream)
{
var response = Stage1 (action, headers, retry, stream);
if (response.StatusCode == HttpStatusCode.NotImplemented || response.StatusDescription == "Not Extended") {
// FIXME is this the right exception type?
throw new UpnpException ("The SOAP request failed.");
} else {
return response;
}
}
ActionResult Invoke(ServiceAction action, IDictionary<string, string> arguments,
Encoding encoding, int retry, bool isFallback)
{
// Because we may do several fallbacks, we serialize to a memory stream and copy that
// to the network stream. That way we only have to serialize once (unless we have to
// try a different encoding scheme).
using (var stream = new MemoryStream ()) {
try {
var headers = new WebHeaderCollection ();
var settings = new XmlWriterSettings { Encoding = encoding };
using (var writer = XmlWriter.Create (stream, settings)) {
action.SerializeRequest (arguments, headers, writer);
}
using (var response = GetResponse (action, headers, retry, stream)) {
if (response.StatusCode == HttpStatusCode.OK) {
return action.DeserializeResponse (response);
} else if (response.StatusCode == HttpStatusCode.InternalServerError) {
if (isFallback) {
action.DeserializeResponseFault (response);
}
return null;
} else if (response.StatusCode == HttpStatusCode.BadRequest) {
return null;
} else {
throw new UpnpException (string.Format (
"There was an unknown error while invoking the action: " +
"the service returned status code {0}.", response.StatusCode));
}
}
} catch (Exception e) {
throw new UpnpException ("There was an unknown error while invoking the action.", e);
}
}
}
internal ActionResult Invoke(ServiceAction action, IDictionary<string, string> arguments, int retry)
{
if (soap_adapter == null) {
if (service_description.ControlUrl == null) {
throw new InvalidOperationException (
string.Format ("{0} does not have a control URL.", service_description));
}
soap_adapter = new SoapInvoker (service_description.ControlUrl);
}
try {
return soap_adapter.Invoke (action, arguments, retry);
} catch (WebException e) {
if (e.Status == WebExceptionStatus.Timeout) {
service_description.CheckDisposed ();
}
throw e;
}
}
HttpWebResponse Final(HttpWebRequest request, ServiceAction action, int retry, Stream stream)
{
stream.Seek (0, SeekOrigin.Begin);
if (!fallback.Chuncked) {
request.ContentLength = stream.Length;
}
using (var output = request.GetRequestStream ()) {
var buffer = new byte[1024];
int count;
while ((count = stream.Read (buffer, 0, 1024)) > 0) {
output.Write (buffer, 0, count);
}
}
return Helper.GetResponse (request, retry);
}
private void WriteMethodSig(CodeMonkey monkey, ServiceAction action, string modifiers, string name, bool includeAttributes)
{
monkey.WriteLine (modifiers);
monkey.Write (action.ReturnArgument != null ? GetTypeName (action.ReturnArgument.RelatedStateVariable.Type) : "void");
monkey.Write (" {0} (", name);
WriteMethodParameters (monkey, action, true, includeAttributes);
monkey.Write (")");
}
HttpWebResponse Stage3Unchunked(HttpWebRequest request, ServiceAction action,
int retry, Stream stream)
{
fallback.Chuncked = false;
request.ProtocolVersion = new Version (1, 0);
request.SendChunked = false;
return Final (request, action, retry, stream);
}
private void WriteMethod(CodeMonkey monkey, ServiceAction action)
{
monkey.WriteLine ("[UpnpAction]");
WriteArgumentAttribute (monkey, action.ReturnArgument);
WriteMethodSig (monkey, action, "public ", action.Name, true);
monkey.StartWriteBlock ();
monkey.WriteLine ("{0}{1}Core (", action.ReturnArgument == null ? "" : "return ", action.Name);
WriteMethodParameters (monkey, action, false, false);
monkey.Write (");");
monkey.EndWriteBlock ();
monkey.WriteLine ();
WriteMethodSig (monkey, action, "public abstract ", action.Name + "Core", false);
monkey.Write (";");
monkey.WriteLine ();
}
private void WriteMethodParameters(CodeMonkey monkey, ServiceAction action, bool definition, bool includeAttributes)
{
bool first = true;
foreach (Argument argument in Concat (action.InArguments.Values, action.OutArguments.Values)) {
if (first) {
first = false;
} else {
monkey.Write (", ");
}
if (definition) {
if (includeAttributes) {
WriteArgumentAttribute (monkey, argument);
}
WriteMethodParameter (monkey, argument);
} else {
monkey.Write ("{0}{1}", argument.Direction == ArgumentDirection.Out ? "out " : "", ToCamelCase (argument.Name));
}
}
}
protected internal Argument(ServiceAction action)
{
if (action == null) throw new ArgumentNullException ("action");
this.action = action;
}
public static void AssertEquality (ServiceAction sourceAction, ServiceAction targetAction)
{
Assert.AreEqual (sourceAction.Name, targetAction.Name);
var source_arguments = sourceAction.Arguments.Values.GetEnumerator ();
var target_arguments = targetAction.Arguments.Values.GetEnumerator ();
while (source_arguments.MoveNext ()) {
Assert.IsTrue (target_arguments.MoveNext ());
AssertEquality (source_arguments.Current, target_arguments.Current);
}
Assert.IsFalse (target_arguments.MoveNext ());
}
protected void AddAction(ServiceAction action)
{
if (action == null) throw new ArgumentNullException ("action");
actions.SetItem (action.Name, action);
}
HttpWebResponse Stage2(RequestProvider requestProvider, ServiceAction action,
WebHeaderCollection headers, int retry, Stream stream)
{
var request = requestProvider (action, headers);
if (fallback.Chuncked) {
return Stage2 (request, action, retry, stream, Stage3Chuncked, Stage3Unchunked);
} else {
return Stage2 (request, action, retry, stream, Stage3Unchunked, Stage3Chuncked);
}
}
HttpWebRequest CreateRequestWithMan(ServiceAction action, WebHeaderCollection headers)
{
fallback.OmitMan = false;
var request = CreateRequest (headers);
request.Method = "M-POST";
request.Headers.Add ("MAN", string.Format (@"""{0}""; ns=01", Protocol.SoapEnvelopeSchema));
request.Headers.Add ("01-SOAPACTION", string.Format (
@"""{0}#{1}""", action.Controller.Description.Type, action.Name));
return request;
}
HttpWebResponse Stage2(HttpWebRequest request, ServiceAction action, int retry, Stream stream,
RequestHandler requestHandler1, RequestHandler requestHandler2)
{
try {
var response = requestHandler1 (request, action, retry, stream);
if (response.StatusCode == HttpStatusCode.HttpVersionNotSupported) {
throw new ProtocolViolationException ();
}
return response;
} catch (ProtocolViolationException) {
return requestHandler2 (request, action, retry, stream);
}
}
HttpWebRequest CreateRequestWithoutMan(ServiceAction action, WebHeaderCollection headers)
{
fallback.OmitMan = true;
var request = CreateRequest (headers);
request.Method = "POST";
request.Headers.Add ("SOAPACTION", string.Format (
@"""{0}#{1}""", action.Controller.Description.Type, action.Name));
return request;
}
public ActionResult Invoke(ServiceAction action, IDictionary<string, string> arguments, int retry)
{
Encoding encoding, fallback_encoding;
if (fallback.UseDefaultUtf8) {
encoding = Encoding.UTF8;
fallback_encoding = fallback_utf8;
} else {
encoding = fallback_utf8;
fallback_encoding = Encoding.UTF8;
}
var result = Invoke (action, arguments, encoding, retry, false);
if (result == null) {
fallback.UseDefaultUtf8 = !fallback.UseDefaultUtf8;
result = Invoke (action, arguments, fallback_encoding, retry, true);
}
return result;
}
public ActionInvocationWindow (ServiceController service, ServiceAction action)
: base (WindowType.Toplevel)
{
this.action = action;
this.Build ();
name.Markup = string.Format ("<big><b>{0}</b></big>", action.Name);
var arguments = new List<Argument> ();
foreach (var argument in action.Arguments) {
if (argument.Value.Direction == ArgumentDirection.In) {
arguments.Add (argument.Value);
}
}
table = new Table ((uint)2, (uint)arguments.Count, false);
var row = (uint)0;
foreach (var argument in arguments) {
table.Attach (new Label (argument.Name), (uint)0, (uint)1, row, row + 1);
Widget widget;
var related_state_variable = service.StateVariables[argument.RelatedStateVariable];
if (related_state_variable.AllowedValues != null) {
var combobox = ComboBox.NewText ();
var i = 0;
var index = i;
foreach (var allowed_value in related_state_variable.AllowedValues) {
combobox.AppendText (allowed_value);
if (allowed_value == related_state_variable.DefaultValue) {
index = i;
}
i++;
}
combobox.Active = index;
widget = combobox;
} else if (related_state_variable.AllowedValueRange != null) {
widget = new SpinButton (
double.Parse (related_state_variable.AllowedValueRange.Minimum),
double.Parse (related_state_variable.AllowedValueRange.Maximum),
double.Parse (related_state_variable.AllowedValueRange.Step));
} else if (related_state_variable.DataType == "i4") {
widget = new SpinButton (int.MinValue, int.MaxValue, 1.0) {
Value = related_state_variable.DefaultValue != null
? double.Parse (related_state_variable.DefaultValue) : 0
};
} else if (related_state_variable.DataType == "ui4") {
widget = new SpinButton (int.MinValue, int.MaxValue, 1.0) {
Value = related_state_variable.DefaultValue != null
? double.Parse (related_state_variable.DefaultValue) : 0
};
} else {
widget = new Entry {
Text = related_state_variable.DefaultValue != null
? related_state_variable.DefaultValue : ""
};
}
table.Attach (widget, (uint)1, (uint)2, row, row + 1);
row++;
}
inputsBox.PackStart (table, true, true, 0);
inputsBox.ShowAll ();
}
