rhodes 2.4.1 → 3.0.0.beta.1

data/platform/wp7/RhoAppRunner/Program.cs

@@ -2,6 +2,9 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
+using System.IO;
+using System.Threading;
+using System.Reflection;
 using Microsoft.SmartDevice.Connectivity;
 
 namespace RhoAppRunner
@@ -15,6 +18,10 @@ namespace RhoAppRunner
 
             bool useEmulator = true;
             Device WP7Device = null;
+
+            if (args[4] == "dev")
+                useEmulator = false;
+
             if (useEmulator)
                 WP7Device = WP7SDK.GetDevices().Single(d => d.Name == "Windows Phone 7 Emulator");
             else
@@ -28,12 +35,22 @@ namespace RhoAppRunner
             RemoteApplication app;
             if (WP7Device.IsApplicationInstalled(appID))
             {
-                Console.WriteLine("Uninstalling sample XAP to Windows Phone 7 Emulator/Device...");
+                Console.WriteLine("Updating sample XAP to Windows Phone 7 Emulator/Device...");
 
                 app = WP7Device.GetApplication(appID);
-                app.Uninstall();
 
-                Console.WriteLine("Sample XAP Uninstalled from Windows Phone 7 Emulator/Device...");
+                //app.Uninstall();
+                app.UpdateApplication(args[1],
+                                      args[2],
+                                      args[3]);
+
+                Console.WriteLine("Sample XAP Updated on Windows Phone 7 Emulator/Device...");
+
+                Console.WriteLine("Launching sample app on Windows Phone 7 Emulator...");
+                app.Launch();
+                Console.WriteLine("Launched sample app on Windows Phone 7 Emulator...");
+
+                return;
             }
 
             Console.WriteLine("Installing sample XAP to Windows Phone 7 Emulator/Device...");

data/platform/wp7/RhoLogServer/Program.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+
+
+namespace RhoLogServer
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            String path = args.Length > 0 ? args[0] : ""; 
+            SocketServer server = new SocketServer(path);
+            while (true)
+            {
+                Thread.Sleep(100);
+            }
+        }
+    }
+}

data/platform/wp7/RhoLogServer/Properties/AssemblyInfo.cs

@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("RhoLogServer")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("RhoLogServer")]
+[assembly: AssemblyCopyright("Copyright ©  2011")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("7787eeff-f7e6-4b27-abc2-afcb5c96b5e9")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

data/platform/wp7/RhoLogServer/RhoLogServer.csproj

@@ -0,0 +1,65 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">x86</Platform>
+    <ProductVersion>8.0.30703</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{896E5017-59D6-41BD-9CBF-191F77237222}</ProjectGuid>
+    <OutputType>WinExe</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>RhoLogServer</RootNamespace>
+    <AssemblyName>RhoLogServer</AssemblyName>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <TargetFrameworkProfile>Client</TargetFrameworkProfile>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
+    <PlatformTarget>x86</PlatformTarget>
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>..\bin\$(RootNamespace)\$(Configuration)</OutputPath>
+    <BaseIntermediateOutputPath>..\bin\$(RootNamespace)</BaseIntermediateOutputPath>
+    <IntermediateOutputPath>..\bin\$(RootNamespace)\$(Configuration)</IntermediateOutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
+    <PlatformTarget>x86</PlatformTarget>
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>..\bin\$(RootNamespace)\$(Configuration)</OutputPath>
+    <BaseIntermediateOutputPath>..\bin\$(RootNamespace)</BaseIntermediateOutputPath>
+    <IntermediateOutputPath>..\bin\$(RootNamespace)\$(Configuration)</IntermediateOutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup>
+    <StartupObject />
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Program.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="SocketServer.cs" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>

data/platform/wp7/RhoLogServer/SocketServer.cs

@@ -0,0 +1,210 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Net.Sockets;
+using System.Net;
+using System.Threading;
+using System.Text;
+using System.IO;
+
+namespace RhoLogServer
+{
+    public partial class SocketServer
+    {
+        const int MAX_CLIENTS = 10;
+        const int PORT = 8000;
+        String m_logPath;
+
+        private Socket m_mainSocket;
+        private List<StateObject> m_workerSocket = new List<StateObject>();
+
+
+
+        public SocketServer(String logPath)
+        {
+            m_logPath = logPath;
+            start_listening();
+        }
+
+        private void start_listening()
+        {
+            try
+            {
+
+                if (m_logPath != null)
+                    File.Delete(m_logPath);
+                // Create the listening socket...
+                m_mainSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
+                IPEndPoint ipLocal = new IPEndPoint(IPAddress.Any, PORT);
+                // Bind to local IP Address...
+                m_mainSocket.Bind(ipLocal);
+                // Start listening...
+                m_mainSocket.Listen(1000);
+                // Create the call back for any client connections...
+                m_mainSocket.BeginAccept(new AsyncCallback(OnClientConnect), null);
+                // m_mainSocket.BeginAccept(new AsyncCallback(AcceptCallback), m_mainSocket);
+
+            }
+            catch (Exception se)
+            {
+                Environment.Exit(0);
+            }
+
+        }
+
+
+        // This is the call back function, which will be invoked when a client is connected
+        public void OnClientConnect(IAsyncResult asyn)
+        {
+            try
+            {
+                // Here we complete/end the BeginAccept() asynchronous call
+                // by calling EndAccept() - which returns the reference to
+                // a new Socket object
+
+                Socket handler = m_mainSocket.EndAccept(asyn);
+                // Let the worker Socket do the further processing for the 
+                // just connected client
+                StateObject state = new StateObject();
+                state.socket = handler;
+                state.id = m_workerSocket.Count;
+
+                m_workerSocket.Add(state);
+                try
+                {
+                    handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReadCallback), state);
+                }
+                catch (SocketException se)
+                {
+                    //MessageBox.Show(se.Message);
+                }
+
+                // Display this client connection as a status message on the GUI	
+                String str = String.Format("Client # {0} connected", m_workerSocket.Count - 1);
+
+                // Since the main Socket is now free, it can go back and wait for
+                // other clients who are attempting to connect
+                m_mainSocket.BeginAccept(new AsyncCallback(OnClientConnect), null);
+
+            }
+            catch (ObjectDisposedException)
+            {
+                
+            }
+            catch (SocketException se)
+            {
+                
+            }
+        }
+
+
+        protected void ReadCallback(IAsyncResult ar)
+        {
+            String content = String.Empty;
+            // Retrieve the state object and the handler socket
+            // from the async state object.
+            StateObject state = (StateObject)ar.AsyncState;
+            Socket handler = state.socket;
+            int id = state.id;
+            try
+            {
+                // Read data from the client socket.
+                int bytesRead = handler.EndReceive(ar);
+
+                if (bytesRead > 0)
+                {
+                    // There might be more data, so store the data received so far.
+                    state.sb.Append(Encoding.UTF8.GetString(state.buffer, 0, bytesRead));
+                    content = state.sb.ToString();
+                    if ((content.Length > 0) || (content.IndexOf("") > -1))
+                    {
+                        Object objData = content;
+                        byte[] byData = System.Text.Encoding.UTF8.GetBytes(objData.ToString());
+                        FileStream st = File.Open(m_logPath, FileMode.OpenOrCreate | FileMode.Append);
+                        st.Write(byData, 0, byData.Length);
+                        st.Close();
+                    }
+                    //handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(this.ReadCallback), state);
+                    //closeSocket(state.id);
+                    closeSocket(state.id);
+                }
+                else
+                {
+                    closeSocket(state.id);
+                }
+            }
+            catch (System.Net.Sockets.SocketException es)
+            {
+                closeSocket(state.id);
+                if (es.ErrorCode != 64)
+                {
+                   
+                }
+            }
+            catch (Exception e)
+            {
+                closeSocket(state.id);
+                if (e.GetType().FullName != "System.ObjectDisposedException")
+                {
+                    
+                }
+            }
+        }
+
+
+
+
+        private void closeSocket(int id)
+        {
+            String str = String.Format("Client # {0} disconnected", m_workerSocket[id].id);
+            m_workerSocket[id].socket.Close();
+            m_workerSocket[id] = null;
+        }
+
+        private String GetIP()
+        {
+            String strHostName = Dns.GetHostName();
+
+            // Find host by name
+            IPHostEntry iphostentry = Dns.GetHostEntry(strHostName);
+
+            // Grab the first IP addresses
+            String IPStr = "";
+            foreach (IPAddress ipaddress in iphostentry.AddressList)
+            {
+                IPStr = ipaddress.ToString();
+                return IPStr;
+            }
+            return IPStr;
+        }
+
+        private void CloseSockets()
+        {
+
+            if (m_mainSocket != null)
+            {
+                m_mainSocket.Close();
+            }
+            for (int i = 0; i < m_workerSocket.Count; i++)
+            {
+                if (m_workerSocket[i] != null)
+                {
+                    m_workerSocket[i].socket.Close();
+                    m_workerSocket[i] = null;
+                }
+            }
+        }
+
+
+        public class StateObject
+        {
+            public Socket socket = null;	// Client socket.
+            public const int BufferSize = 65000;	// Size of receive buffer.
+            public byte[] buffer = new byte[BufferSize];// Receive buffer.
+            public StringBuilder sb = new StringBuilder();//Received data String.
+            public int id = -1; // client id.
+        }
+
+
+    }
+}

data/platform/wp7/RhoRubyExtGen/RhoAsyncHttp.cs

@@ -26,6 +26,12 @@ namespace rho.rubyext
 
             }
 
+            [RubyMethodAttribute("cancel", RubyMethodAttributes.PublicSingleton)]
+            public static void Cancel(RubyModule/*!*/ self)
+            {
+
+            }
+
             [RubyMethodAttribute("do_request", RubyMethodAttributes.PublicSingleton)]
             public static MutableString doRequest(RubyModule/*!*/ self, [NotNull]String command, Hash args)
             {

data/platform/wp7/RhoRubyLib/Initializers.Generated.cs

@@ -109,8 +109,9 @@ namespace rho.rubyext {
         
         private static void LoadRho__AsyncHttp_Class(IronRuby.Builtins.RubyModule/*!*/ module) {
             DefineLibraryMethod(module, "cancel", 0x21, 
-                0x00000002U, 
-                new Action<IronRuby.Builtins.RubyModule, System.String>(rho.rubyext.RhoRoot.RhoAsyncHttp.Cancel)
+                0x00000002U, 0x00000000U, 
+                new Action<IronRuby.Builtins.RubyModule, System.String>(rho.rubyext.RhoRoot.RhoAsyncHttp.Cancel), 
+                new Action<IronRuby.Builtins.RubyModule>(rho.rubyext.RhoRoot.RhoAsyncHttp.Cancel)
             );
             
             DefineLibraryMethod(module, "do_request", 0x21, 

data/platform/wp7/RhoRubyLib/RhoRuby.cs

@@ -54,6 +54,77 @@ namespace rho
             }
         }
 
+        class CRhoOutputStream : Stream
+        {
+            private static RhoLogger LOG = RhoLogger.RHO_STRIP_LOG ? new RhoEmptyLogger() :
+                        new RhoLogger("APP");
+
+            private bool m_bError = false;
+            public CRhoOutputStream(bool bError) { m_bError = bError; }
+
+            public override bool CanRead
+            {
+                get { return false; }
+            }
+
+            public override bool CanSeek
+            {
+                get { return false; }
+            }
+
+            public override bool CanWrite
+            {
+                get { return true; }
+            }
+
+            public override void Flush()
+            {
+            
+            }
+
+            public override long Length
+            {
+                get { throw new NotSupportedException(); }
+            }
+
+            public override long Position
+            {
+                get { throw new NotSupportedException(); }
+                set { throw new NotSupportedException(); }
+            }
+
+            public override int Read(byte[]/*!*/ buffer, int offset, int count)
+            {
+                throw new NotSupportedException();
+            }
+
+            public override long Seek(long offset, SeekOrigin origin)
+            {
+                throw new NotSupportedException();
+            }
+
+            public override void SetLength(long value)
+            {
+                throw new NotSupportedException();
+            }
+
+            public override void Write(byte[]/*!*/ buffer, int offset, int count)
+            {
+                if (count == 0)
+                    return;
+
+                if (count == 1 && buffer[0] == 10 || buffer[0] == 13)
+                    return;
+
+                String str = System.Text.Encoding.UTF8.GetString(buffer, offset, count);
+
+                if (m_bError)
+                    LOG.ERROR(str);
+                else
+                    LOG.INFO(str);
+            }
+        }
+
         private void initRuby()
         {
             ScriptRuntimeSetup runtimeSetup = ScriptRuntimeSetup.ReadConfiguration();
@@ -68,6 +139,11 @@ namespace rho
             languageSetup.Options["Verbosity"] = 2;
 
             m_runtime = IronRuby.Ruby.CreateRuntime(runtimeSetup);
+            Stream errStream = new CRhoOutputStream(true);
+            m_runtime.IO.SetErrorOutput(errStream, new StreamWriter(errStream, System.Text.Encoding.UTF8));
+            Stream outStream = new CRhoOutputStream(false);
+            m_runtime.IO.SetOutput(outStream, new StreamWriter(outStream, System.Text.Encoding.UTF8));
+
             m_engine = IronRuby.Ruby.GetEngine(m_runtime);
             m_context = (RubyContext)Microsoft.Scripting.Hosting.Providers.HostingHelpers.GetLanguageContext(m_engine);
 
@@ -77,6 +153,12 @@ namespace rho
                 RubyMethodVisibility.Public,
                 m_context.ObjectClass
             ));
+            m_context.ObjectClass.AddMethod(m_context, "__rho_exist_in_resources", new RubyLibraryMethodInfo(
+                new[] { LibraryOverload.Create(new Func<System.Object, System.String, System.Object>(RhoKernelOps.__rho_exist_in_resources), false, 0, 0) },
+                RubyMethodVisibility.Public,
+                m_context.ObjectClass
+            ));
+
             m_context.Loader.LoadAssembly("RhoRubyLib", "rho.rubyext.rubyextLibraryInitializer", true, true);
 
             System.Collections.ObjectModel.Collection<string> paths = new System.Collections.ObjectModel.Collection<string>();