From 17fc8fa92036227c99360750b1befcd8c47c9228 Mon Sep 17 00:00:00 2001 From: Hylke Bons Date: Wed, 1 Feb 2012 16:23:49 +0000 Subject: [PATCH 01/17] listener: Rework disconnect algorithm --- SparkleLib/SparkleListenerBase.cs | 148 +++++++++++++----------- SparkleLib/SparkleListenerTcp.cs | 185 ++++++++++++++++++------------ SparkleLib/SparkleRepoBase.cs | 2 +- 3 files changed, 195 insertions(+), 140 deletions(-) diff --git a/SparkleLib/SparkleListenerBase.cs b/SparkleLib/SparkleListenerBase.cs index 1770c04a..9c173dc7 100755 --- a/SparkleLib/SparkleListenerBase.cs +++ b/SparkleLib/SparkleListenerBase.cs @@ -64,7 +64,7 @@ namespace SparkleLib { SparkleHelpers.DebugInfo ("ListenerFactory", "Refered to existing listener for " + announce_uri); - listener.AlsoListenTo (folder_identifier); + listener.AlsoListenToBase (folder_identifier); return (SparkleListenerBase) listener; } } @@ -90,40 +90,52 @@ namespace SparkleLib { // listens for change notifications public abstract class SparkleListenerBase { - // We've connected to the server public event ConnectedEventHandler Connected; public delegate void ConnectedEventHandler (); - // We've disconnected from the server public event DisconnectedEventHandler Disconnected; public delegate void DisconnectedEventHandler (); - // We've been notified about a remote - // change by the channel - public event AnnouncementEventHandler Announcement; - public delegate void AnnouncementEventHandler (SparkleAnnouncement announcement); + public event ReceivedEventHandler Received; + public delegate void ReceivedEventHandler (SparkleAnnouncement announcement); + + public readonly Uri Server; + public abstract void Connect (); - public abstract void Announce (SparkleAnnouncement announcent); - public abstract void AlsoListenTo (string folder_identifier); public abstract bool IsConnected { get; } + public abstract bool IsConnecting { get; } + protected abstract void Announce (SparkleAnnouncement announcent); + protected abstract void AlsoListenTo (string folder_identifier); + protected List channels = new List (); - protected Dictionary> recent_announcements = new Dictionary> (); - protected int max_recent_announcements = 10; - protected Dictionary queue_up = new Dictionary (); - protected Dictionary queue_down = new Dictionary (); - protected bool is_connecting; - protected Uri server; - protected Timer reconnect_timer = new Timer { Interval = 60 * 1000, Enabled = true }; + + + private int max_recent_announcements = 10; + + private Dictionary> recent_announcements = + new Dictionary> (); + + private Dictionary queue_up = + new Dictionary (); + + private Dictionary queue_down = + new Dictionary (); + + private Timer reconnect_timer = new Timer { + Interval = 60 * 1000, + Enabled = true + }; public SparkleListenerBase (Uri server, string folder_identifier) { - this.server = server; + Server = server; + this.channels.Add (folder_identifier); this.reconnect_timer.Elapsed += delegate { - if (!IsConnected && !this.is_connecting) + if (!IsConnected && !IsConnecting) Reconnect (); }; @@ -133,29 +145,46 @@ namespace SparkleLib { public void AnnounceBase (SparkleAnnouncement announcement) { - if (!this.IsRecentAnnounement (announcement)) { + if (!IsRecentAnnouncement (announcement)) { if (IsConnected) { SparkleHelpers.DebugInfo ("Listener", - "Announcing message " + announcement.Message + " to " + announcement.FolderIdentifier + " on " + this.server); + "Announcing message " + announcement.Message + " to " + + announcement.FolderIdentifier + " on " + Server); Announce (announcement); - this.AddRecentAnnouncement (announcement); + AddRecentAnnouncement (announcement); + } else { - SparkleHelpers.DebugInfo ("Listener", "Can't send message to " + this.server + ". Queuing message"); + SparkleHelpers.DebugInfo ("Listener", + "Can't send message to " + + Server + ". Queuing message"); + this.queue_up [announcement.FolderIdentifier] = announcement; } } else { SparkleHelpers.DebugInfo ("Listener", - "Already processed message " + announcement.Message + " to " + announcement.FolderIdentifier + " from " + this.server); + "Already processed message " + announcement.Message + " to " + + announcement.FolderIdentifier + " from " + Server); } + } + + public void AlsoListenToBase (string channel) + { + if (!this.channels.Contains (channel) && IsConnected) { + SparkleHelpers.DebugInfo ("Listener", + "Subscribing to channel " + channel); + + this.channels.Add (channel); + AlsoListenTo (channel); + } } public void Reconnect () { - SparkleHelpers.DebugInfo ("Listener", "Trying to reconnect to " + this.server); + SparkleHelpers.DebugInfo ("Listener", "Trying to reconnect to " + Server); Connect (); } @@ -168,7 +197,8 @@ namespace SparkleLib { Connected (); if (this.queue_up.Count > 0) { - SparkleHelpers.DebugInfo ("Listener", "Delivering " + this.queue_up.Count + " queued messages..."); + SparkleHelpers.DebugInfo ("Listener", + "Delivering " + this.queue_up.Count + " queued messages..."); foreach (KeyValuePair item in this.queue_up) { SparkleAnnouncement announcement = item.Value; @@ -180,9 +210,9 @@ namespace SparkleLib { } - public void OnDisconnected () + public void OnDisconnected (string message) { - SparkleHelpers.DebugInfo ("Listener", "Signal of " + Server + " lost"); + SparkleHelpers.DebugInfo ("Listener", "Disconnected from " + Server + ": " + message); if (Disconnected != null) Disconnected (); @@ -192,34 +222,46 @@ namespace SparkleLib { public void OnAnnouncement (SparkleAnnouncement announcement) { SparkleHelpers.DebugInfo ("Listener", - "Got message " + announcement.Message + " from " + announcement.FolderIdentifier + " on " + this.server); + "Got message " + announcement.Message + " from " + + announcement.FolderIdentifier + " on " + Server); - if (IsRecentAnnounement(announcement) ){ + if (IsRecentAnnouncement (announcement)) { SparkleHelpers.DebugInfo ("Listener", "Ignoring previously processed message " + announcement.Message + - " from " + announcement.FolderIdentifier + " on " + this.server); + " from " + announcement.FolderIdentifier + " on " + Server); return; } SparkleHelpers.DebugInfo ("Listener", - "Processing message " + announcement.Message + " from " + announcement.FolderIdentifier + " on " + this.server); + "Processing message " + announcement.Message + " from " + + announcement.FolderIdentifier + " on " + Server); AddRecentAnnouncement (announcement); this.queue_down [announcement.FolderIdentifier] = announcement; - if (Announcement != null) - Announcement (announcement); + if (Received != null) + Received (announcement); } - private bool IsRecentAnnounement (SparkleAnnouncement announcement) + public virtual void Dispose () { - if (!HasRecentAnnouncements (announcement.FolderIdentifier)) { + this.reconnect_timer.Dispose (); + } + + + private bool IsRecentAnnouncement (SparkleAnnouncement announcement) + { + if (!this.recent_announcements + .ContainsKey (announcement.FolderIdentifier)) { + return false; } else { - foreach (SparkleAnnouncement recent_announcement in GetRecentAnnouncements (announcement.FolderIdentifier)) { + foreach (SparkleAnnouncement recent_announcement in + GetRecentAnnouncements (announcement.FolderIdentifier)) { + if (recent_announcement.Message.Equals (announcement.Message)) return true; } @@ -240,39 +282,15 @@ namespace SparkleLib { private void AddRecentAnnouncement (SparkleAnnouncement announcement) { - List recent_announcements = this.GetRecentAnnouncements (announcement.FolderIdentifier); + List recent_announcements = + GetRecentAnnouncements (announcement.FolderIdentifier); - if (!IsRecentAnnounement (announcement)) + if (!IsRecentAnnouncement (announcement)) recent_announcements.Add (announcement); if (recent_announcements.Count > this.max_recent_announcements) - recent_announcements.RemoveRange (0, (recent_announcements.Count - this.max_recent_announcements)); - } - - - private bool HasRecentAnnouncements (string folder_identifier) - { - return this.recent_announcements.ContainsKey (folder_identifier); - } - - - public virtual void Dispose () - { - this.reconnect_timer.Dispose (); - } - - - public Uri Server { - get { - return this.server; - } - } - - - public bool IsConnecting { - get { - return this.is_connecting; - } + recent_announcements.RemoveRange (0, + (recent_announcements.Count - this.max_recent_announcements)); } } } diff --git a/SparkleLib/SparkleListenerTcp.cs b/SparkleLib/SparkleListenerTcp.cs index 15268a94..76db72bf 100755 --- a/SparkleLib/SparkleListenerTcp.cs +++ b/SparkleLib/SparkleListenerTcp.cs @@ -19,6 +19,7 @@ using System; using System.IO; using System.Text; using System.Threading; +using System.Net.NetworkInformation; using System.Net.Sockets; using System.Security.Cryptography; using System.Collections.Generic; @@ -28,30 +29,31 @@ namespace SparkleLib { public class SparkleListenerTcp : SparkleListenerBase { - private Thread thread; - - // these are shared - private readonly Object mutex = new Object(); private Socket socket; - private bool connected; + private Object socket_lock = new Object (); + private Thread thread; + private bool is_connected = false; + private bool is_connecting = false; + public SparkleListenerTcp (Uri server, string folder_identifier) : base (server, folder_identifier) { - base.channels.Add (folder_identifier); - this.connected = false; } public override bool IsConnected { get { - bool result = false; + lock (this.socket_lock) + return this.is_connected; + } + } - lock (this.mutex) { - result = this.connected; - } - return result; + public override bool IsConnecting { + get { + lock (this.socket_lock) + return this.is_connecting; } } @@ -61,65 +63,88 @@ namespace SparkleLib { { SparkleHelpers.DebugInfo ("ListenerTcp", "Connecting to " + Server.Host); - base.is_connecting = true; + this.is_connecting = true; this.thread = new Thread ( new ThreadStart (delegate { - try { - // Connect and subscribe to the channel - int port = Server.Port; - if (port < 0) port = 9999; + int port = Server.Port; - lock (this.mutex) { - this.socket = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); + if (port < 0) + port = 1986; + + try { + lock (this.socket_lock) { + this.socket = new Socket (AddressFamily.InterNetwork, + SocketType.Stream, ProtocolType.Tcp); + + // TODO: our own time comparison to account for system sleep? + this.socket.ReceiveTimeout = 30 * 1000; + this.socket.Blocking = true; this.socket.Connect (Server.Host, port); - base.is_connecting = false; - this.connected = true; + this.is_connecting = false; + this.is_connected = true; OnConnected (); foreach (string channel in base.channels) { - SparkleHelpers.DebugInfo ("ListenerTcp", "Subscribing to channel " + channel); - this.socket.Send (Encoding.UTF8.GetBytes ("subscribe " + channel + "\n")); + SparkleHelpers.DebugInfo ("ListenerTcp", + "Subscribing to channel " + channel); + + byte [] subscribe_bytes = + Encoding.UTF8.GetBytes ("subscribe " + channel + "\n"); + + this.socket.Send (subscribe_bytes); } } - byte [] bytes = new byte [4096]; + } catch (SocketException e) { + this.is_connected = false; + this.is_connecting = false; - // List to the channels, this blocks the thread - while (this.socket.Connected) { - int bytes_read = this.socket.Receive (bytes); + OnDisconnected (e.Message); + return; + } - if (bytes_read > 0) { - string received = Encoding.UTF8.GetString (bytes); - string line = received.Substring (0, received.IndexOf ("\n")); - if (!line.Contains ("!")) - continue; - string folder_identifier = line.Substring (0, line.IndexOf ("!")); - string message = this.CleanMessage (line.Substring (line.IndexOf ("!") + 1)); - if (!folder_identifier.Equals("debug") && - !String.IsNullOrEmpty(message)) - OnAnnouncement (new SparkleAnnouncement (folder_identifier, message)); - } else { - SparkleHelpers.DebugInfo ("ListenerTcp", "Error on socket"); - lock (this.mutex) { + byte [] bytes = new byte [4096]; + int bytes_read = 0; + + // List to the channels, this blocks the thread + while (this.socket.Connected) { + try { + bytes_read = this.socket.Receive (bytes); + + } catch (Exception e) { + if (!PingHost (Server.Host)) { + lock (this.socket_lock) { this.socket.Close (); - this.connected = false; + this.is_connected = false; - OnDisconnected (); + OnDisconnected (e.Message); } } } - SparkleHelpers.DebugInfo ("ListenerTcp", "Disconnected from " + Server.Host); + if (bytes_read > 0) { + string received = Encoding.UTF8.GetString (bytes); + string line = received.Substring (0, received.IndexOf ("\n")); - } catch (SocketException e) { - SparkleHelpers.DebugInfo ("ListenerTcp", "Could not connect to " + Server + ": " + e.Message); + if (!line.Contains ("!")) + continue; - OnDisconnected (); + string folder_identifier = line.Substring (0, line.IndexOf ("!")); + string message = CleanMessage (line.Substring (line.IndexOf ("!") + 1)); + + if (!folder_identifier.Equals ("debug") && + !String.IsNullOrEmpty (message)) { + + OnAnnouncement (new SparkleAnnouncement (folder_identifier, message)); + } + } } + + OnDisconnected (""); }) ); @@ -127,46 +152,38 @@ namespace SparkleLib { } - public override void AlsoListenTo (string folder_identifier) + protected override void AlsoListenTo (string folder_identifier) { - string channel = folder_identifier; + string to_send = "subscribe " + folder_identifier + "\n"; - if (!base.channels.Contains (channel)) { - base.channels.Add (channel); - - if (IsConnected) { - SparkleHelpers.DebugInfo ("ListenerTcp", "Subscribing to channel " + channel); - - string to_send = "subscribe " + folder_identifier + "\n"; - - try { - lock (this.mutex) { - this.socket.Send (Encoding.UTF8.GetBytes (to_send)); - } - - } catch (SocketException e) { - SparkleHelpers.DebugInfo ("ListenerTcp", "Could not connect to " + Server + ": " + e.Message); - OnDisconnected (); - } + try { + lock (this.socket_lock) { + this.socket.Send (Encoding.UTF8.GetBytes (to_send)); } + + } catch (SocketException e) { + this.is_connected = false; + this.is_connecting = false; + + OnDisconnected (e.Message); } } - public override void Announce (SparkleAnnouncement announcement) + protected override void Announce (SparkleAnnouncement announcement) { string to_send = "announce " + announcement.FolderIdentifier + " " + announcement.Message + "\n"; try { - - lock (this.mutex) { + lock (this.socket_lock) this.socket.Send (Encoding.UTF8.GetBytes (to_send)); - } - } catch (SocketException e) { - SparkleHelpers.DebugInfo ("ListenerTcp", "Could not connect to " + Server + ": " + e.Message); - OnDisconnected (); + } catch (SocketException e) { + this.is_connected = false; + this.is_connecting = false; + + OnDisconnected (e.Message); } } @@ -175,12 +192,32 @@ namespace SparkleLib { { this.thread.Abort (); this.thread.Join (); + base.Dispose (); } - private string CleanMessage(string message) + + private string CleanMessage (string message) { - return message.Trim ().Replace ("\n", "").Replace ("\0", ""); + return message.Trim () + .Replace ("\n", "") + .Replace ("\0", ""); + } + + + private bool PingHost (string host) + { + Ping ping = new Ping (); + PingOptions options = new PingOptions () { + DontFragment = true + }; + + string data = "00000000000000000000000000000000"; + byte [] buffer = Encoding.ASCII.GetBytes (data); + + PingReply reply = ping.Send (host, 15, buffer, options); + + return reply.Status == IPStatus.Success; } } } diff --git a/SparkleLib/SparkleRepoBase.cs b/SparkleLib/SparkleRepoBase.cs index 2ff71f35..6cf73a1e 100755 --- a/SparkleLib/SparkleRepoBase.cs +++ b/SparkleLib/SparkleRepoBase.cs @@ -299,7 +299,7 @@ namespace SparkleLib { }; // Fetch changes when there is a message in the irc channel - this.listener.Announcement += delegate (SparkleAnnouncement announcement) { + this.listener.Received += delegate (SparkleAnnouncement announcement) { string identifier = Identifier; if (announcement.FolderIdentifier.Equals (identifier) && From 68934067a92d805e1d5c6a229b98537c27bdf493 Mon Sep 17 00:00:00 2001 From: Hylke Bons Date: Wed, 1 Feb 2012 22:04:58 +0000 Subject: [PATCH 02/17] listener: Use ping mechanism through te socked, instead of an external one --- SparkleLib/SparkleListenerTcp.cs | 68 ++++++++++++++++---------------- SparkleLib/SparkleRepoBase.cs | 16 ++++---- 2 files changed, 43 insertions(+), 41 deletions(-) diff --git a/SparkleLib/SparkleListenerTcp.cs b/SparkleLib/SparkleListenerTcp.cs index 76db72bf..afc66b5f 100755 --- a/SparkleLib/SparkleListenerTcp.cs +++ b/SparkleLib/SparkleListenerTcp.cs @@ -75,11 +75,13 @@ namespace SparkleLib { try { lock (this.socket_lock) { this.socket = new Socket (AddressFamily.InterNetwork, - SocketType.Stream, ProtocolType.Tcp); + SocketType.Stream, ProtocolType.Tcp) { - // TODO: our own time comparison to account for system sleep? - this.socket.ReceiveTimeout = 30 * 1000; - this.socket.Blocking = true; + ReceiveTimeout = 60 * 1000, + SendTimeout = 3 * 1000 + }; + + // Try to connect to the server this.socket.Connect (Server.Host, port); this.is_connecting = false; @@ -87,6 +89,7 @@ namespace SparkleLib { OnConnected (); + // Subscribe to channels of interest to us foreach (string channel in base.channels) { SparkleHelpers.DebugInfo ("ListenerTcp", "Subscribing to channel " + channel); @@ -110,22 +113,39 @@ namespace SparkleLib { byte [] bytes = new byte [4096]; int bytes_read = 0; - // List to the channels, this blocks the thread - while (this.socket.Connected) { + // Wait for messages + while (true) { try { + // This blocks the thread bytes_read = this.socket.Receive (bytes); - } catch (Exception e) { - if (!PingHost (Server.Host)) { - lock (this.socket_lock) { - this.socket.Close (); - this.is_connected = false; + // We've timed out, let's ping the server to + // see if the connection is still up + } catch (SocketException e) { + try { + byte [] ping_bytes = + Encoding.UTF8.GetBytes ("ping"); - OnDisconnected (e.Message); - } + this.socket.Send (ping_bytes); + this.socket.ReceiveTimeout = 3 * 1000; + + // 10057 means "Socket is not connected" + if (this.socket.Receive (bytes) < 1) + throw new SocketException (10057); + + // The ping failed: disconnect completely + } catch (SocketException) { + this.is_connected = false; + this.is_connecting = false; + + this.socket.ReceiveTimeout = 60 * 1000; + + OnDisconnected (e.Message); + return; } } + // Parse the received message if (bytes_read > 0) { string received = Encoding.UTF8.GetString (bytes); string line = received.Substring (0, received.IndexOf ("\n")); @@ -139,12 +159,11 @@ namespace SparkleLib { if (!folder_identifier.Equals ("debug") && !String.IsNullOrEmpty (message)) { + // We have a message! OnAnnouncement (new SparkleAnnouncement (folder_identifier, message)); } } } - - OnDisconnected (""); }) ); @@ -157,9 +176,8 @@ namespace SparkleLib { string to_send = "subscribe " + folder_identifier + "\n"; try { - lock (this.socket_lock) { + lock (this.socket_lock) this.socket.Send (Encoding.UTF8.GetBytes (to_send)); - } } catch (SocketException e) { this.is_connected = false; @@ -203,21 +221,5 @@ namespace SparkleLib { .Replace ("\n", "") .Replace ("\0", ""); } - - - private bool PingHost (string host) - { - Ping ping = new Ping (); - PingOptions options = new PingOptions () { - DontFragment = true - }; - - string data = "00000000000000000000000000000000"; - byte [] buffer = Encoding.ASCII.GetBytes (data); - - PingReply reply = ping.Send (host, 15, buffer, options); - - return reply.Status == IPStatus.Success; - } } } diff --git a/SparkleLib/SparkleRepoBase.cs b/SparkleLib/SparkleRepoBase.cs index 6cf73a1e..2d3c2c17 100755 --- a/SparkleLib/SparkleRepoBase.cs +++ b/SparkleLib/SparkleRepoBase.cs @@ -45,7 +45,7 @@ namespace SparkleLib { private System.Timers.Timer local_timer = new System.Timers.Timer () { Interval = 0.25 * 1000 }; private System.Timers.Timer remote_timer = new System.Timers.Timer () { Interval = 10 * 1000 }; private DateTime last_poll = DateTime.Now; - private List sizebuffer = new List (); + private List size_buffer = new List (); private bool has_changed = false; private Object change_lock = new Object (); private Object watch_lock = new Object (); @@ -336,16 +336,16 @@ namespace SparkleLib { { lock (this.change_lock) { if (this.has_changed) { - if (this.sizebuffer.Count >= 4) - this.sizebuffer.RemoveAt (0); + if (this.size_buffer.Count >= 4) + this.size_buffer.RemoveAt (0); DirectoryInfo dir_info = new DirectoryInfo (LocalPath); - this.sizebuffer.Add (CalculateSize (dir_info)); + this.size_buffer.Add (CalculateSize (dir_info)); - if (this.sizebuffer.Count >= 4 && - this.sizebuffer [0].Equals (this.sizebuffer [1]) && - this.sizebuffer [1].Equals (this.sizebuffer [2]) && - this.sizebuffer [2].Equals (this.sizebuffer [3])) { + if (this.size_buffer.Count >= 4 && + this.size_buffer [0].Equals (this.size_buffer [1]) && + this.size_buffer [1].Equals (this.size_buffer [2]) && + this.size_buffer [2].Equals (this.size_buffer [3])) { SparkleHelpers.DebugInfo ("Local", "[" + Name + "] Changes have settled."); this.is_buffering = false; From 2097daee79678fab97cf203449e3eb04918c515b Mon Sep 17 00:00:00 2001 From: Hylke Bons Date: Wed, 1 Feb 2012 22:17:43 +0000 Subject: [PATCH 03/17] listener: fix potential endless loop --- SparkleLib/SparkleListenerTcp.cs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/SparkleLib/SparkleListenerTcp.cs b/SparkleLib/SparkleListenerTcp.cs index afc66b5f..cee4762a 100755 --- a/SparkleLib/SparkleListenerTcp.cs +++ b/SparkleLib/SparkleListenerTcp.cs @@ -114,7 +114,7 @@ namespace SparkleLib { int bytes_read = 0; // Wait for messages - while (true) { + while (this.is_connected) { try { // This blocks the thread bytes_read = this.socket.Receive (bytes); @@ -141,7 +141,7 @@ namespace SparkleLib { this.socket.ReceiveTimeout = 60 * 1000; OnDisconnected (e.Message); - return; + break; } } From 19ba40712940001700ebca87bf75f97e66493af2 Mon Sep 17 00:00:00 2001 From: Hylke Bons Date: Sun, 5 Feb 2012 22:28:06 +0100 Subject: [PATCH 04/17] Add some debug output --- SparkleLib/SparkleListenerTcp.cs | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/SparkleLib/SparkleListenerTcp.cs b/SparkleLib/SparkleListenerTcp.cs index cee4762a..90909e38 100755 --- a/SparkleLib/SparkleListenerTcp.cs +++ b/SparkleLib/SparkleListenerTcp.cs @@ -126,12 +126,20 @@ namespace SparkleLib { byte [] ping_bytes = Encoding.UTF8.GetBytes ("ping"); + Console.WriteLine ("1"); + this.socket.Send (ping_bytes); this.socket.ReceiveTimeout = 3 * 1000; + Console.WriteLine ("2"); + // 10057 means "Socket is not connected" - if (this.socket.Receive (bytes) < 1) + if (this.socket.Receive (bytes) < 1) { + Console.WriteLine ("3"); throw new SocketException (10057); + } + + Console.WriteLine ("4"); // The ping failed: disconnect completely } catch (SocketException) { From d437b1a5a1188e913ec8f0ac32d9745148464ec4 Mon Sep 17 00:00:00 2001 From: Hylke Bons Date: Sun, 5 Feb 2012 22:59:06 +0100 Subject: [PATCH 05/17] tcp listener: remove some unneeded references --- SparkleLib/SparkleListenerBase.cs | 2 -- SparkleLib/SparkleListenerTcp.cs | 10 +++++----- 2 files changed, 5 insertions(+), 7 deletions(-) diff --git a/SparkleLib/SparkleListenerBase.cs b/SparkleLib/SparkleListenerBase.cs index 9c173dc7..9f5c3476 100755 --- a/SparkleLib/SparkleListenerBase.cs +++ b/SparkleLib/SparkleListenerBase.cs @@ -16,10 +16,8 @@ using System; -using System.Collections; using System.Collections.Generic; using System.Timers; -using System.Linq; namespace SparkleLib { diff --git a/SparkleLib/SparkleListenerTcp.cs b/SparkleLib/SparkleListenerTcp.cs index 90909e38..ef80630e 100755 --- a/SparkleLib/SparkleListenerTcp.cs +++ b/SparkleLib/SparkleListenerTcp.cs @@ -16,14 +16,9 @@ using System; -using System.IO; using System.Text; using System.Threading; -using System.Net.NetworkInformation; using System.Net.Sockets; -using System.Security.Cryptography; -using System.Collections.Generic; -using System.Xml.Serialization; namespace SparkleLib { @@ -122,6 +117,9 @@ namespace SparkleLib { // We've timed out, let's ping the server to // see if the connection is still up } catch (SocketException e) { + + Console.WriteLine ("1st catch block"); + try { byte [] ping_bytes = Encoding.UTF8.GetBytes ("ping"); @@ -148,6 +146,8 @@ namespace SparkleLib { this.socket.ReceiveTimeout = 60 * 1000; + Console.WriteLine ("2nd catch block"); + OnDisconnected (e.Message); break; } From 873f2deee836d0cc5485e2aecff0e6b52db6927a Mon Sep 17 00:00:00 2001 From: Hylke Bons Date: Sun, 5 Feb 2012 23:05:47 +0100 Subject: [PATCH 06/17] listener: add some comments and cleanups --- SparkleLib/SparkleListenerBase.cs | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-) diff --git a/SparkleLib/SparkleListenerBase.cs b/SparkleLib/SparkleListenerBase.cs index 9f5c3476..b9ce5271 100755 --- a/SparkleLib/SparkleListenerBase.cs +++ b/SparkleLib/SparkleListenerBase.cs @@ -39,8 +39,11 @@ namespace SparkleLib { private static List listeners = new List (); + public static SparkleListenerBase CreateListener (string folder_name, string folder_identifier) { + // TODO: Allow a different announcements uri for each folder + // next to a global one string uri = SparkleConfig.DefaultConfig.GetFolderOptionalAttribute ( folder_name, "announcements_url"); @@ -48,7 +51,10 @@ namespace SparkleLib { // This is SparkleShare's centralized notification service. // Don't worry, we only use this server as a backup if you // don't have your own. All data needed to connect is hashed and - // we don't store any personal information ever + // we don't store any personal information ever. + // + // Please see the SparkleShare wiki if you wish to run + // your own service instead uri = "tcp://notifications.sparkleshare.org:1986"; } @@ -60,7 +66,8 @@ namespace SparkleLib { foreach (SparkleListenerBase listener in listeners) { if (listener.Server.Equals (announce_uri)) { SparkleHelpers.DebugInfo ("ListenerFactory", - "Refered to existing listener for " + announce_uri); + "Refered to existing " + announce_uri.Scheme + + " listener for " + announce_uri); listener.AlsoListenToBase (folder_identifier); return (SparkleListenerBase) listener; @@ -78,7 +85,9 @@ namespace SparkleLib { break; } - SparkleHelpers.DebugInfo ("ListenerFactory", "Issued new listener for " + announce_uri); + SparkleHelpers.DebugInfo ("ListenerFactory", + "Issued new " + announce_uri.Scheme + " listener for " + announce_uri); + return (SparkleListenerBase) listeners [listeners.Count - 1]; } } From aa82b3441fb3ee252664094b6abd1951d402a7ca Mon Sep 17 00:00:00 2001 From: Hylke Bons Date: Mon, 6 Feb 2012 12:54:04 +0100 Subject: [PATCH 07/17] listener: update comments --- SparkleLib/SparkleListenerBase.cs | 10 +++++++--- SparkleLib/SparkleListenerTcp.cs | 2 +- 2 files changed, 8 insertions(+), 4 deletions(-) diff --git a/SparkleLib/SparkleListenerBase.cs b/SparkleLib/SparkleListenerBase.cs index b9ce5271..704f62f6 100755 --- a/SparkleLib/SparkleListenerBase.cs +++ b/SparkleLib/SparkleListenerBase.cs @@ -49,9 +49,13 @@ namespace SparkleLib { if (uri == null) { // This is SparkleShare's centralized notification service. - // Don't worry, we only use this server as a backup if you - // don't have your own. All data needed to connect is hashed and - // we don't store any personal information ever. + // It communicates "It's time to sync!" signals between clients. + // + // Here's how it works: the client listens to a channel (the + // folder identifier, a SHA-1 hash) for when it's time to sync. + // Clients also send the current revision hash to the channel + // for other clients to pick up when you've synced up any + // changes. This way // // Please see the SparkleShare wiki if you wish to run // your own service instead diff --git a/SparkleLib/SparkleListenerTcp.cs b/SparkleLib/SparkleListenerTcp.cs index ef80630e..5a6734f4 100755 --- a/SparkleLib/SparkleListenerTcp.cs +++ b/SparkleLib/SparkleListenerTcp.cs @@ -16,9 +16,9 @@ using System; +using System.Net.Sockets; using System.Text; using System.Threading; -using System.Net.Sockets; namespace SparkleLib { From c43abafdab2226eed47bf87d5da39f044febafd7 Mon Sep 17 00:00:00 2001 From: Hylke Bons Date: Mon, 6 Feb 2012 13:04:12 +0100 Subject: [PATCH 08/17] listener factory: allow setting of a global notification service for all the folders --- SparkleLib/SparkleConfig.cs | 1 + SparkleLib/SparkleListenerBase.cs | 18 ++++++++++++------ 2 files changed, 13 insertions(+), 6 deletions(-) diff --git a/SparkleLib/SparkleConfig.cs b/SparkleLib/SparkleConfig.cs index cef5ba82..405f05c4 100755 --- a/SparkleLib/SparkleConfig.cs +++ b/SparkleLib/SparkleConfig.cs @@ -29,6 +29,7 @@ namespace SparkleLib { Environment.GetFolderPath (Environment.SpecialFolder.ApplicationData), "sparkleshare"); + // TODO: declare elsewhere public static SparkleConfig DefaultConfig = new SparkleConfig (default_config_path, "config.xml"); public static bool DebugMode = true; diff --git a/SparkleLib/SparkleListenerBase.cs b/SparkleLib/SparkleListenerBase.cs index 704f62f6..fafdc829 100755 --- a/SparkleLib/SparkleListenerBase.cs +++ b/SparkleLib/SparkleListenerBase.cs @@ -42,12 +42,16 @@ namespace SparkleLib { public static SparkleListenerBase CreateListener (string folder_name, string folder_identifier) { - // TODO: Allow a different announcements uri for each folder - // next to a global one - string uri = SparkleConfig.DefaultConfig.GetFolderOptionalAttribute ( - folder_name, "announcements_url"); + // Check if the user wants to use a global custom notification service + string uri = SparkleConfig.DefaultConfig.GetConfigOption ("announcements_url"); - if (uri == null) { + // Check if the user wants a use a custom notification service for this folder + if (string.IsNullOrEmpty (uri)) + uri = SparkleConfig.DefaultConfig.GetFolderOptionalAttribute ( + folder_name, "announcements_url"); + + // Fall back to the fallback service is neither is the case + if (string.IsNullOrEmpty (uri)) { // This is SparkleShare's centralized notification service. // It communicates "It's time to sync!" signals between clients. // @@ -65,7 +69,7 @@ namespace SparkleLib { Uri announce_uri = new Uri (uri); - // We use only one listener per server to keep + // We use only one listener per notification service to keep // the number of connections as low as possible foreach (SparkleListenerBase listener in listeners) { if (listener.Server.Equals (announce_uri)) { @@ -73,6 +77,8 @@ namespace SparkleLib { "Refered to existing " + announce_uri.Scheme + " listener for " + announce_uri); + // We already seem to have a listener for this server, + // refer to the existing one instead listener.AlsoListenToBase (folder_identifier); return (SparkleListenerBase) listener; } From fc09a1e6da50769b69ec4eb90799f95f85ae8406 Mon Sep 17 00:00:00 2001 From: Hylke Bons Date: Mon, 6 Feb 2012 13:45:20 +0100 Subject: [PATCH 09/17] listener: move classes to separate files --- SparkleLib/Makefile.am | 2 + SparkleLib/SparkleAnnouncement.cs | 35 +++++++++++ SparkleLib/SparkleLib.csproj | 4 +- SparkleLib/SparkleListenerBase.cs | 83 ------------------------- SparkleLib/SparkleListenerFactory.cs | 89 +++++++++++++++++++++++++++ SparkleShare/Mac/SparkleStatusIcon.cs | 1 + 6 files changed, 130 insertions(+), 84 deletions(-) create mode 100644 SparkleLib/SparkleAnnouncement.cs create mode 100644 SparkleLib/SparkleListenerFactory.cs diff --git a/SparkleLib/Makefile.am b/SparkleLib/Makefile.am index 92a45ea8..30484fe1 100755 --- a/SparkleLib/Makefile.am +++ b/SparkleLib/Makefile.am @@ -6,6 +6,7 @@ SOURCES = \ Git/SparkleFetcherGit.cs \ Git/SparkleGit.cs \ Git/SparkleRepoGit.cs \ + SparkleAnnouncement.cs \ SparkleBackend.cs \ SparkleChangeSet.cs \ SparkleConfig.cs \ @@ -13,6 +14,7 @@ SOURCES = \ SparkleFetcherBase.cs \ SparkleHelpers.cs \ SparkleListenerBase.cs \ + SparkleListenerFactory.cs \ SparkleListenerTcp.cs \ SparkleRepoBase.cs \ SparkleWatcher.cs diff --git a/SparkleLib/SparkleAnnouncement.cs b/SparkleLib/SparkleAnnouncement.cs new file mode 100644 index 00000000..a05068b7 --- /dev/null +++ b/SparkleLib/SparkleAnnouncement.cs @@ -0,0 +1,35 @@ +// SparkleShare, a collaboration and sharing tool. +// Copyright (C) 2010 Hylke Bons +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + + +using System; +using System.Collections.Generic; + +namespace SparkleLib { + + public class SparkleAnnouncement { + + public readonly string FolderIdentifier; + public readonly string Message; + + + public SparkleAnnouncement (string folder_identifier, string message) + { + FolderIdentifier = folder_identifier; + Message = message; + } + } +} diff --git a/SparkleLib/SparkleLib.csproj b/SparkleLib/SparkleLib.csproj index 1c708116..211a786a 100755 --- a/SparkleLib/SparkleLib.csproj +++ b/SparkleLib/SparkleLib.csproj @@ -40,12 +40,14 @@ + - + + diff --git a/SparkleLib/SparkleListenerBase.cs b/SparkleLib/SparkleListenerBase.cs index fafdc829..8c20f850 100755 --- a/SparkleLib/SparkleListenerBase.cs +++ b/SparkleLib/SparkleListenerBase.cs @@ -21,88 +21,6 @@ using System.Timers; namespace SparkleLib { - public class SparkleAnnouncement { - - public readonly string FolderIdentifier; - public readonly string Message; - - - public SparkleAnnouncement (string folder_identifier, string message) - { - FolderIdentifier = folder_identifier; - Message = message; - } - } - - - public static class SparkleListenerFactory { - - private static List listeners = new List (); - - - public static SparkleListenerBase CreateListener (string folder_name, string folder_identifier) - { - // Check if the user wants to use a global custom notification service - string uri = SparkleConfig.DefaultConfig.GetConfigOption ("announcements_url"); - - // Check if the user wants a use a custom notification service for this folder - if (string.IsNullOrEmpty (uri)) - uri = SparkleConfig.DefaultConfig.GetFolderOptionalAttribute ( - folder_name, "announcements_url"); - - // Fall back to the fallback service is neither is the case - if (string.IsNullOrEmpty (uri)) { - // This is SparkleShare's centralized notification service. - // It communicates "It's time to sync!" signals between clients. - // - // Here's how it works: the client listens to a channel (the - // folder identifier, a SHA-1 hash) for when it's time to sync. - // Clients also send the current revision hash to the channel - // for other clients to pick up when you've synced up any - // changes. This way - // - // Please see the SparkleShare wiki if you wish to run - // your own service instead - - uri = "tcp://notifications.sparkleshare.org:1986"; - } - - Uri announce_uri = new Uri (uri); - - // We use only one listener per notification service to keep - // the number of connections as low as possible - foreach (SparkleListenerBase listener in listeners) { - if (listener.Server.Equals (announce_uri)) { - SparkleHelpers.DebugInfo ("ListenerFactory", - "Refered to existing " + announce_uri.Scheme + - " listener for " + announce_uri); - - // We already seem to have a listener for this server, - // refer to the existing one instead - listener.AlsoListenToBase (folder_identifier); - return (SparkleListenerBase) listener; - } - } - - // Create a new listener with the appropriate - // type if one doesn't exist yet for that server - switch (announce_uri.Scheme) { - case "tcp": - listeners.Add (new SparkleListenerTcp (announce_uri, folder_identifier)); - break; - default: - listeners.Add (new SparkleListenerTcp (announce_uri, folder_identifier)); - break; - } - - SparkleHelpers.DebugInfo ("ListenerFactory", - "Issued new " + announce_uri.Scheme + " listener for " + announce_uri); - - return (SparkleListenerBase) listeners [listeners.Count - 1]; - } - } - - // A persistent connection to the server that // listens for change notifications public abstract class SparkleListenerBase { @@ -311,4 +229,3 @@ namespace SparkleLib { } } } - diff --git a/SparkleLib/SparkleListenerFactory.cs b/SparkleLib/SparkleListenerFactory.cs new file mode 100644 index 00000000..e4021c29 --- /dev/null +++ b/SparkleLib/SparkleListenerFactory.cs @@ -0,0 +1,89 @@ +// SparkleShare, a collaboration and sharing tool. +// Copyright (C) 2010 Hylke Bons +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + + +using System; +using System.Collections.Generic; + +namespace SparkleLib { + + public static class SparkleListenerFactory { + + private static List listeners = new List (); + + + public static SparkleListenerBase CreateListener (string folder_name, string folder_identifier) + { + // Check if the user wants to use a global custom notification service + string uri = SparkleConfig.DefaultConfig.GetConfigOption ("announcements_url"); + + // Check if the user wants a use a custom notification service for this folder + if (string.IsNullOrEmpty (uri)) + uri = SparkleConfig.DefaultConfig.GetFolderOptionalAttribute ( + folder_name, "announcements_url"); + + // Fall back to the fallback service is neither is the case + if (string.IsNullOrEmpty (uri)) { + // This is SparkleShare's centralized notification service. + // It communicates "It's time to sync!" signals between clients. + // + // Here's how it works: the client listens to a channel (the + // folder identifier, a SHA-1 hash) for when it's time to sync. + // Clients also send the current revision hash to the channel + // for other clients to pick up when you've synced up any + // changes. This way + // + // Please see the SparkleShare wiki if you wish to run + // your own service instead + + uri = "tcp://notifications.sparkleshare.org:1986"; + } + + Uri announce_uri = new Uri (uri); + + // We use only one listener per notification service to keep + // the number of connections as low as possible + foreach (SparkleListenerBase listener in listeners) { + if (listener.Server.Equals (announce_uri)) { + SparkleHelpers.DebugInfo ("ListenerFactory", + "Refered to existing " + announce_uri.Scheme + + " listener for " + announce_uri); + + // We already seem to have a listener for this server, + // refer to the existing one instead + listener.AlsoListenToBase (folder_identifier); + return (SparkleListenerBase) listener; + } + } + + // Create a new listener with the appropriate + // type if one doesn't exist yet for that server + switch (announce_uri.Scheme) { + case "tcp": + listeners.Add (new SparkleListenerTcp (announce_uri, folder_identifier)); + break; + default: + listeners.Add (new SparkleListenerTcp (announce_uri, folder_identifier)); + break; + } + + SparkleHelpers.DebugInfo ("ListenerFactory", + "Issued new " + announce_uri.Scheme + " listener for " + announce_uri); + + return (SparkleListenerBase) listeners [listeners.Count - 1]; + } + } +} diff --git a/SparkleShare/Mac/SparkleStatusIcon.cs b/SparkleShare/Mac/SparkleStatusIcon.cs index 0d89e9b1..231fe902 100755 --- a/SparkleShare/Mac/SparkleStatusIcon.cs +++ b/SparkleShare/Mac/SparkleStatusIcon.cs @@ -33,6 +33,7 @@ namespace SparkleShare { public SparkleStatusIconController Controller = new SparkleStatusIconController (); + // TODO: Fix case private Timer Animation; private int FrameNumber; private string StateText; From f02e5e9e97bc3f1b75232d948eaa3f4730da3a3a Mon Sep 17 00:00:00 2001 From: Hylke Bons Date: Mon, 6 Feb 2012 13:48:16 +0100 Subject: [PATCH 10/17] remove unneeded file SparkleOptions.cs --- SparkleLib/SparkleOptions.cs | 1101 ---------------------------------- 1 file changed, 1101 deletions(-) delete mode 100755 SparkleLib/SparkleOptions.cs diff --git a/SparkleLib/SparkleOptions.cs b/SparkleLib/SparkleOptions.cs deleted file mode 100755 index b071c429..00000000 --- a/SparkleLib/SparkleOptions.cs +++ /dev/null @@ -1,1101 +0,0 @@ -// -// Options.cs -// -// Authors: -// Jonathan Pryor -// -// Copyright (C) 2008 Novell (http://www.novell.com) -// -// Permission is hereby granted, free of charge, to any person obtaining -// a copy of this software and associated documentation files (the -// "Software"), to deal in the Software without restriction, including -// without limitation the rights to use, copy, modify, merge, publish, -// distribute, sublicense, and/or sell copies of the Software, and to -// permit persons to whom the Software is furnished to do so, subject to -// the following conditions: -// -// The above copyright notice and this permission notice shall be -// included in all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND -// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE -// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION -// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION -// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -// - -// Compile With: -// gmcs -debug+ -r:System.Core Options.cs -o:NDesk.Options.dll -// gmcs -debug+ -d:LINQ -r:System.Core Options.cs -o:NDesk.Options.dll -// -// The LINQ version just changes the implementation of -// OptionSet.Parse(IEnumerable), and confers no semantic changes. - -// -// A Getopt::Long-inspired option parsing library for C#. -// -// NDesk.Options.OptionSet is built upon a key/value table, where the -// key is a option format string and the value is a delegate that is -// invoked when the format string is matched. -// -// Option format strings: -// Regex-like BNF Grammar: -// name: .+ -// type: [=:] -// sep: ( [^{}]+ | '{' .+ '}' )? -// aliases: ( name type sep ) ( '|' name type sep )* -// -// Each '|'-delimited name is an alias for the associated action. If the -// format string ends in a '=', it has a required value. If the format -// string ends in a ':', it has an optional value. If neither '=' or ':' -// is present, no value is supported. `=' or `:' need only be defined on one -// alias, but if they are provided on more than one they must be consistent. -// -// Each alias portion may also end with a "key/value separator", which is used -// to split option values if the option accepts > 1 value. If not specified, -// it defaults to '=' and ':'. If specified, it can be any character except -// '{' and '}' OR the *string* between '{' and '}'. If no separator should be -// used (i.e. the separate values should be distinct arguments), then "{}" -// should be used as the separator. -// -// Options are extracted either from the current option by looking for -// the option name followed by an '=' or ':', or is taken from the -// following option IFF: -// - The current option does not contain a '=' or a ':' -// - The current option requires a value (i.e. not a Option type of ':') -// -// The `name' used in the option format string does NOT include any leading -// option indicator, such as '-', '--', or '/'. All three of these are -// permitted/required on any named option. -// -// Option bundling is permitted so long as: -// - '-' is used to start the option group -// - all of the bundled options are a single character -// - at most one of the bundled options accepts a value, and the value -// provided starts from the next character to the end of the string. -// -// This allows specifying '-a -b -c' as '-abc', and specifying '-D name=value' -// as '-Dname=value'. -// -// Option processing is disabled by specifying "--". All options after "--" -// are returned by OptionSet.Parse() unchanged and unprocessed. -// -// Unprocessed options are returned from OptionSet.Parse(). -// -// Examples: -// int verbose = 0; -// OptionSet p = new OptionSet () -// .Add ("v", v => ++verbose) -// .Add ("name=|value=", v => Console.WriteLine (v)); -// p.Parse (new string[]{"-v", "--v", "/v", "-name=A", "/name", "B", "extra"}); -// -// The above would parse the argument string array, and would invoke the -// lambda expression three times, setting `verbose' to 3 when complete. -// It would also print out "A" and "B" to standard output. -// The returned array would contain the string "extra". -// -// C# 3.0 collection initializers are supported and encouraged: -// var p = new OptionSet () { -// { "h|?|help", v => ShowHelp () }, -// }; -// -// System.ComponentModel.TypeConverter is also supported, allowing the use of -// custom data types in the callback type; TypeConverter.ConvertFromString() -// is used to convert the value option to an instance of the specified -// type: -// -// var p = new OptionSet () { -// { "foo=", (Foo f) => Console.WriteLine (f.ToString ()) }, -// }; -// -// Random other tidbits: -// - Boolean options (those w/o '=' or ':' in the option format string) -// are explicitly enabled if they are followed with '+', and explicitly -// disabled if they are followed with '-': -// string a = null; -// var p = new OptionSet () { -// { "a", s => a = s }, -// }; -// p.Parse (new string[]{"-a"}); // sets v != null -// p.Parse (new string[]{"-a+"}); // sets v != null -// p.Parse (new string[]{"-a-"}); // sets v == null -// - -using System; -using System.Collections; -using System.Collections.Generic; -using System.Collections.ObjectModel; -using System.ComponentModel; -using System.Globalization; -using System.IO; -using System.Runtime.Serialization; -using System.Security.Permissions; -using System.Text; -using System.Text.RegularExpressions; - -#if LINQ -using System.Linq; -#endif - -#if TEST -using NDesk.Options; -#endif - -#if NDESK_OPTIONS -namespace NDesk.Options -#else -namespace SparkleLib.Options -#endif -{ - public class OptionValueCollection : IList, IList { - - List values = new List (); - OptionContext c; - - internal OptionValueCollection (OptionContext c) - { - this.c = c; - } - - #region ICollection - void ICollection.CopyTo (Array array, int index) {(values as ICollection).CopyTo (array, index);} - bool ICollection.IsSynchronized {get {return (values as ICollection).IsSynchronized;}} - object ICollection.SyncRoot {get {return (values as ICollection).SyncRoot;}} - #endregion - - #region ICollection - public void Add (string item) {values.Add (item);} - public void Clear () {values.Clear ();} - public bool Contains (string item) {return values.Contains (item);} - public void CopyTo (string[] array, int arrayIndex) {values.CopyTo (array, arrayIndex);} - public bool Remove (string item) {return values.Remove (item);} - public int Count {get {return values.Count;}} - public bool IsReadOnly {get {return false;}} - #endregion - - #region IEnumerable - IEnumerator IEnumerable.GetEnumerator () {return values.GetEnumerator ();} - #endregion - - #region IEnumerable - public IEnumerator GetEnumerator () {return values.GetEnumerator ();} - #endregion - - #region IList - int IList.Add (object value) {return (values as IList).Add (value);} - bool IList.Contains (object value) {return (values as IList).Contains (value);} - int IList.IndexOf (object value) {return (values as IList).IndexOf (value);} - void IList.Insert (int index, object value) {(values as IList).Insert (index, value);} - void IList.Remove (object value) {(values as IList).Remove (value);} - void IList.RemoveAt (int index) {(values as IList).RemoveAt (index);} - bool IList.IsFixedSize {get {return false;}} - object IList.this [int index] {get {return this [index];} set {(values as IList)[index] = value;}} - #endregion - - #region IList - public int IndexOf (string item) {return values.IndexOf (item);} - public void Insert (int index, string item) {values.Insert (index, item);} - public void RemoveAt (int index) {values.RemoveAt (index);} - - private void AssertValid (int index) - { - if (c.Option == null) - throw new InvalidOperationException ("OptionContext.Option is null."); - if (index >= c.Option.MaxValueCount) - throw new ArgumentOutOfRangeException ("index"); - if (c.Option.OptionValueType == OptionValueType.Required && - index >= values.Count) - throw new OptionException (string.Format ( - c.OptionSet.MessageLocalizer ("Missing required value for option '{0}'."), c.OptionName), - c.OptionName); - } - - public string this [int index] { - get { - AssertValid (index); - return index >= values.Count ? null : values [index]; - } - set { - values [index] = value; - } - } - #endregion - - public List ToList () - { - return new List (values); - } - - public string[] ToArray () - { - return values.ToArray (); - } - - public override string ToString () - { - return string.Join (", ", values.ToArray ()); - } - } - - public class OptionContext { - private Option option; - private string name; - private int index; - private OptionSet set; - private OptionValueCollection c; - - public OptionContext (OptionSet set) - { - this.set = set; - this.c = new OptionValueCollection (this); - } - - public Option Option { - get {return option;} - set {option = value;} - } - - public string OptionName { - get {return name;} - set {name = value;} - } - - public int OptionIndex { - get {return index;} - set {index = value;} - } - - public OptionSet OptionSet { - get {return set;} - } - - public OptionValueCollection OptionValues { - get {return c;} - } - } - - public enum OptionValueType { - None, - Optional, - Required, - } - - public abstract class Option { - string prototype, description; - string[] names; - OptionValueType type; - int count; - string[] separators; - - protected Option (string prototype, string description) - : this (prototype, description, 1) - { - } - - protected Option (string prototype, string description, int maxValueCount) - { - if (prototype == null) - throw new ArgumentNullException ("prototype"); - if (prototype.Length == 0) - throw new ArgumentException ("Cannot be the empty string.", "prototype"); - if (maxValueCount < 0) - throw new ArgumentOutOfRangeException ("maxValueCount"); - - this.prototype = prototype; - this.names = prototype.Split ('|'); - this.description = description; - this.count = maxValueCount; - this.type = ParsePrototype (); - - if (this.count == 0 && type != OptionValueType.None) - throw new ArgumentException ( - "Cannot provide maxValueCount of 0 for OptionValueType.Required or " + - "OptionValueType.Optional.", - "maxValueCount"); - if (this.type == OptionValueType.None && maxValueCount > 1) - throw new ArgumentException ( - string.Format ("Cannot provide maxValueCount of {0} for OptionValueType.None.", maxValueCount), - "maxValueCount"); - if (Array.IndexOf (names, "<>") >= 0 && - ((names.Length == 1 && this.type != OptionValueType.None) || - (names.Length > 1 && this.MaxValueCount > 1))) - throw new ArgumentException ( - "The default option handler '<>' cannot require values.", - "prototype"); - } - - public string Prototype {get {return prototype;}} - public string Description {get {return description;}} - public OptionValueType OptionValueType {get {return type;}} - public int MaxValueCount {get {return count;}} - - public string[] GetNames () - { - return (string[]) names.Clone (); - } - - public string[] GetValueSeparators () - { - if (separators == null) - return new string [0]; - return (string[]) separators.Clone (); - } - - protected static T Parse (string value, OptionContext c) - { - Type tt = typeof (T); - bool nullable = tt.IsValueType && tt.IsGenericType && - !tt.IsGenericTypeDefinition && - tt.GetGenericTypeDefinition () == typeof (Nullable<>); - Type targetType = nullable ? tt.GetGenericArguments () [0] : typeof (T); - TypeConverter conv = TypeDescriptor.GetConverter (targetType); - T t = default (T); - try { - if (value != null) - t = (T) conv.ConvertFromString (value); - } - catch (Exception e) { - throw new OptionException ( - string.Format ( - c.OptionSet.MessageLocalizer ("Could not convert string `{0}' to type {1} for option `{2}'."), - value, targetType.Name, c.OptionName), - c.OptionName, e); - } - return t; - } - - internal string[] Names {get {return names;}} - internal string[] ValueSeparators {get {return separators;}} - - static readonly char[] NameTerminator = new char[]{'=', ':'}; - - private OptionValueType ParsePrototype () - { - char type = '\0'; - List seps = new List (); - for (int i = 0; i < names.Length; ++i) { - string name = names [i]; - if (name.Length == 0) - throw new ArgumentException ("Empty option names are not supported.", "prototype"); - - int end = name.IndexOfAny (NameTerminator); - if (end == -1) - continue; - names [i] = name.Substring (0, end); - if (type == '\0' || type == name [end]) - type = name [end]; - else - throw new ArgumentException ( - string.Format ("Conflicting option types: '{0}' vs. '{1}'.", type, name [end]), - "prototype"); - AddSeparators (name, end, seps); - } - - if (type == '\0') - return OptionValueType.None; - - if (count <= 1 && seps.Count != 0) - throw new ArgumentException ( - string.Format ("Cannot provide key/value separators for Options taking {0} value(s).", count), - "prototype"); - if (count > 1) { - if (seps.Count == 0) - this.separators = new string[]{":", "="}; - else if (seps.Count == 1 && seps [0].Length == 0) - this.separators = null; - else - this.separators = seps.ToArray (); - } - - return type == '=' ? OptionValueType.Required : OptionValueType.Optional; - } - - private static void AddSeparators (string name, int end, ICollection seps) - { - int start = -1; - for (int i = end+1; i < name.Length; ++i) { - switch (name [i]) { - case '{': - if (start != -1) - throw new ArgumentException ( - string.Format ("Ill-formed name/value separator found in \"{0}\".", name), - "prototype"); - start = i+1; - break; - case '}': - if (start == -1) - throw new ArgumentException ( - string.Format ("Ill-formed name/value separator found in \"{0}\".", name), - "prototype"); - seps.Add (name.Substring (start, i-start)); - start = -1; - break; - default: - if (start == -1) - seps.Add (name [i].ToString ()); - break; - } - } - if (start != -1) - throw new ArgumentException ( - string.Format ("Ill-formed name/value separator found in \"{0}\".", name), - "prototype"); - } - - public void Invoke (OptionContext c) - { - OnParseComplete (c); - c.OptionName = null; - c.Option = null; - c.OptionValues.Clear (); - } - - protected abstract void OnParseComplete (OptionContext c); - - public override string ToString () - { - return Prototype; - } - } - - [Serializable] - public class OptionException : Exception { - private string option; - - public OptionException () - { - } - - public OptionException (string message, string optionName) - : base (message) - { - this.option = optionName; - } - - public OptionException (string message, string optionName, Exception innerException) - : base (message, innerException) - { - this.option = optionName; - } - - protected OptionException (SerializationInfo info, StreamingContext context) - : base (info, context) - { - this.option = info.GetString ("OptionName"); - } - - public string OptionName { - get {return this.option;} - } - - [SecurityPermission (SecurityAction.LinkDemand, SerializationFormatter = true)] - public override void GetObjectData (SerializationInfo info, StreamingContext context) - { - base.GetObjectData (info, context); - info.AddValue ("OptionName", option); - } - } - - public delegate void OptionAction (TKey key, TValue value); - - public class OptionSet : KeyedCollection - { - public OptionSet () - : this (delegate (string f) {return f;}) - { - } - - public OptionSet (Converter localizer) - { - this.localizer = localizer; - } - - Converter localizer; - - public Converter MessageLocalizer { - get {return localizer;} - } - - protected override string GetKeyForItem (Option item) - { - if (item == null) - throw new ArgumentNullException ("option"); - if (item.Names != null && item.Names.Length > 0) - return item.Names [0]; - // This should never happen, as it's invalid for Option to be - // constructed w/o any names. - throw new InvalidOperationException ("Option has no names!"); - } - - [Obsolete ("Use KeyedCollection.this[string]")] - protected Option GetOptionForName (string option) - { - if (option == null) - throw new ArgumentNullException ("option"); - try { - return base [option]; - } - catch (KeyNotFoundException) { - return null; - } - } - - protected override void InsertItem (int index, Option item) - { - base.InsertItem (index, item); - AddImpl (item); - } - - protected override void RemoveItem (int index) - { - base.RemoveItem (index); - Option p = Items [index]; - // KeyedCollection.RemoveItem() handles the 0th item - for (int i = 1; i < p.Names.Length; ++i) { - Dictionary.Remove (p.Names [i]); - } - } - - protected override void SetItem (int index, Option item) - { - base.SetItem (index, item); - RemoveItem (index); - AddImpl (item); - } - - private void AddImpl (Option option) - { - if (option == null) - throw new ArgumentNullException ("option"); - List added = new List (option.Names.Length); - try { - // KeyedCollection.InsertItem/SetItem handle the 0th name. - for (int i = 1; i < option.Names.Length; ++i) { - Dictionary.Add (option.Names [i], option); - added.Add (option.Names [i]); - } - } - catch (Exception) { - foreach (string name in added) - Dictionary.Remove (name); - throw; - } - } - - public new OptionSet Add (Option option) - { - base.Add (option); - return this; - } - - sealed class ActionOption : Option { - Action action; - - public ActionOption (string prototype, string description, int count, Action action) - : base (prototype, description, count) - { - if (action == null) - throw new ArgumentNullException ("action"); - this.action = action; - } - - protected override void OnParseComplete (OptionContext c) - { - action (c.OptionValues); - } - } - - public OptionSet Add (string prototype, Action action) - { - return Add (prototype, null, action); - } - - public OptionSet Add (string prototype, string description, Action action) - { - if (action == null) - throw new ArgumentNullException ("action"); - Option p = new ActionOption (prototype, description, 1, - delegate (OptionValueCollection v) { action (v [0]); }); - base.Add (p); - return this; - } - - public OptionSet Add (string prototype, OptionAction action) - { - return Add (prototype, null, action); - } - - public OptionSet Add (string prototype, string description, OptionAction action) - { - if (action == null) - throw new ArgumentNullException ("action"); - Option p = new ActionOption (prototype, description, 2, - delegate (OptionValueCollection v) {action (v [0], v [1]);}); - base.Add (p); - return this; - } - - sealed class ActionOption : Option { - Action action; - - public ActionOption (string prototype, string description, Action action) - : base (prototype, description, 1) - { - if (action == null) - throw new ArgumentNullException ("action"); - this.action = action; - } - - protected override void OnParseComplete (OptionContext c) - { - action (Parse (c.OptionValues [0], c)); - } - } - - sealed class ActionOption : Option { - OptionAction action; - - public ActionOption (string prototype, string description, OptionAction action) - : base (prototype, description, 2) - { - if (action == null) - throw new ArgumentNullException ("action"); - this.action = action; - } - - protected override void OnParseComplete (OptionContext c) - { - action ( - Parse (c.OptionValues [0], c), - Parse (c.OptionValues [1], c)); - } - } - - public OptionSet Add (string prototype, Action action) - { - return Add (prototype, null, action); - } - - public OptionSet Add (string prototype, string description, Action action) - { - return Add (new ActionOption (prototype, description, action)); - } - - public OptionSet Add (string prototype, OptionAction action) - { - return Add (prototype, null, action); - } - - public OptionSet Add (string prototype, string description, OptionAction action) - { - return Add (new ActionOption (prototype, description, action)); - } - - protected virtual OptionContext CreateOptionContext () - { - return new OptionContext (this); - } - -#if LINQ - public List Parse (IEnumerable arguments) - { - bool process = true; - OptionContext c = CreateOptionContext (); - c.OptionIndex = -1; - var def = GetOptionForName ("<>"); - var unprocessed = - from argument in arguments - where ++c.OptionIndex >= 0 && (process || def != null) - ? process - ? argument == "--" - ? (process = false) - : !Parse (argument, c) - ? def != null - ? Unprocessed (null, def, c, argument) - : true - : false - : def != null - ? Unprocessed (null, def, c, argument) - : true - : true - select argument; - List r = unprocessed.ToList (); - if (c.Option != null) - c.Option.Invoke (c); - return r; - } -#else - public List Parse (IEnumerable arguments) - { - OptionContext c = CreateOptionContext (); - c.OptionIndex = -1; - bool process = true; - List unprocessed = new List (); - Option def = Contains ("<>") ? this ["<>"] : null; - foreach (string argument in arguments) { - ++c.OptionIndex; - if (argument == "--") { - process = false; - continue; - } - if (!process) { - Unprocessed (unprocessed, def, c, argument); - continue; - } - if (!Parse (argument, c)) - Unprocessed (unprocessed, def, c, argument); - } - if (c.Option != null) - c.Option.Invoke (c); - return unprocessed; - } -#endif - - private static bool Unprocessed (ICollection extra, Option def, OptionContext c, string argument) - { - if (def == null) { - extra.Add (argument); - return false; - } - c.OptionValues.Add (argument); - c.Option = def; - c.Option.Invoke (c); - return false; - } - - private readonly Regex ValueOption = new Regex ( - @"^(?--|-|/)(?[^:=]+)((?[:=])(?.*))?$"); - - protected bool GetOptionParts (string argument, out string flag, out string name, out string sep, out string value) - { - if (argument == null) - throw new ArgumentNullException ("argument"); - - flag = name = sep = value = null; - Match m = ValueOption.Match (argument); - if (!m.Success) { - return false; - } - flag = m.Groups ["flag"].Value; - name = m.Groups ["name"].Value; - if (m.Groups ["sep"].Success && m.Groups ["value"].Success) { - sep = m.Groups ["sep"].Value; - value = m.Groups ["value"].Value; - } - return true; - } - - protected virtual bool Parse (string argument, OptionContext c) - { - if (c.Option != null) { - ParseValue (argument, c); - return true; - } - - string f, n, s, v; - if (!GetOptionParts (argument, out f, out n, out s, out v)) - return false; - - Option p; - if (Contains (n)) { - p = this [n]; - c.OptionName = f + n; - c.Option = p; - switch (p.OptionValueType) { - case OptionValueType.None: - c.OptionValues.Add (n); - c.Option.Invoke (c); - break; - case OptionValueType.Optional: - case OptionValueType.Required: - ParseValue (v, c); - break; - } - return true; - } - // no match; is it a bool option? - if (ParseBool (argument, n, c)) - return true; - // is it a bundled option? - if (ParseBundledValue (f, string.Concat (n + s + v), c)) - return true; - - return false; - } - - private void ParseValue (string option, OptionContext c) - { - if (option != null) - foreach (string o in c.Option.ValueSeparators != null - ? option.Split (c.Option.ValueSeparators, StringSplitOptions.None) - : new string[]{option}) { - c.OptionValues.Add (o); - } - if (c.OptionValues.Count == c.Option.MaxValueCount || - c.Option.OptionValueType == OptionValueType.Optional) - c.Option.Invoke (c); - else if (c.OptionValues.Count > c.Option.MaxValueCount) { - throw new OptionException (localizer (string.Format ( - "Error: Found {0} option values when expecting {1}.", - c.OptionValues.Count, c.Option.MaxValueCount)), - c.OptionName); - } - } - - private bool ParseBool (string option, string n, OptionContext c) - { - Option p; - string rn; - if (n.Length >= 1 && (n [n.Length-1] == '+' || n [n.Length-1] == '-') && - Contains ((rn = n.Substring (0, n.Length-1)))) { - p = this [rn]; - string v = n [n.Length-1] == '+' ? option : null; - c.OptionName = option; - c.Option = p; - c.OptionValues.Add (v); - p.Invoke (c); - return true; - } - return false; - } - - private bool ParseBundledValue (string f, string n, OptionContext c) - { - if (f != "-") - return false; - for (int i = 0; i < n.Length; ++i) { - Option p; - string opt = f + n [i].ToString (); - string rn = n [i].ToString (); - if (!Contains (rn)) { - if (i == 0) - return false; - throw new OptionException (string.Format (localizer ( - "Cannot bundle unregistered option '{0}'."), opt), opt); - } - p = this [rn]; - switch (p.OptionValueType) { - case OptionValueType.None: - Invoke (c, opt, n, p); - break; - case OptionValueType.Optional: - case OptionValueType.Required: { - string v = n.Substring (i+1); - c.Option = p; - c.OptionName = opt; - ParseValue (v.Length != 0 ? v : null, c); - return true; - } - default: - throw new InvalidOperationException ("Unknown OptionValueType: " + p.OptionValueType); - } - } - return true; - } - - private static void Invoke (OptionContext c, string name, string value, Option option) - { - c.OptionName = name; - c.Option = option; - c.OptionValues.Add (value); - option.Invoke (c); - } - - private const int OptionWidth = 29; - - public void WriteOptionDescriptions (TextWriter o) - { - foreach (Option p in this) { - int written = 0; - if (!WriteOptionPrototype (o, p, ref written)) - continue; - - if (written < OptionWidth) - o.Write (new string (' ', OptionWidth - written)); - else { - o.WriteLine (); - o.Write (new string (' ', OptionWidth)); - } - - bool indent = false; - string prefix = new string (' ', OptionWidth+2); - foreach (string line in GetLines (localizer (GetDescription (p.Description)))) { - if (indent) - o.Write (prefix); - o.WriteLine (line); - indent = true; - } - } - } - - bool WriteOptionPrototype (TextWriter o, Option p, ref int written) - { - string[] names = p.Names; - - int i = GetNextOptionIndex (names, 0); - if (i == names.Length) - return false; - - if (names [i].Length == 1) { - Write (o, ref written, " -"); - Write (o, ref written, names [0]); - } - else { - Write (o, ref written, " --"); - Write (o, ref written, names [0]); - } - - for ( i = GetNextOptionIndex (names, i+1); - i < names.Length; i = GetNextOptionIndex (names, i+1)) { - Write (o, ref written, ", "); - Write (o, ref written, names [i].Length == 1 ? "-" : "--"); - Write (o, ref written, names [i]); - } - - if (p.OptionValueType == OptionValueType.Optional || - p.OptionValueType == OptionValueType.Required) { - if (p.OptionValueType == OptionValueType.Optional) { - Write (o, ref written, localizer ("[")); - } - Write (o, ref written, localizer ("=" + GetArgumentName (0, p.MaxValueCount, p.Description))); - string sep = p.ValueSeparators != null && p.ValueSeparators.Length > 0 - ? p.ValueSeparators [0] - : " "; - for (int c = 1; c < p.MaxValueCount; ++c) { - Write (o, ref written, localizer (sep + GetArgumentName (c, p.MaxValueCount, p.Description))); - } - if (p.OptionValueType == OptionValueType.Optional) { - Write (o, ref written, localizer ("]")); - } - } - return true; - } - - static int GetNextOptionIndex (string[] names, int i) - { - while (i < names.Length && names [i] == "<>") { - ++i; - } - return i; - } - - static void Write (TextWriter o, ref int n, string s) - { - n += s.Length; - o.Write (s); - } - - private static string GetArgumentName (int index, int maxIndex, string description) - { - if (description == null) - return maxIndex == 1 ? "VALUE" : "VALUE" + (index + 1); - string[] nameStart; - if (maxIndex == 1) - nameStart = new string[]{"{0:", "{"}; - else - nameStart = new string[]{"{" + index + ":"}; - for (int i = 0; i < nameStart.Length; ++i) { - int start, j = 0; - do { - start = description.IndexOf (nameStart [i], j); - } while (start >= 0 && j != 0 ? description [j++ - 1] == '{' : false); - if (start == -1) - continue; - int end = description.IndexOf ("}", start); - if (end == -1) - continue; - return description.Substring (start + nameStart [i].Length, end - start - nameStart [i].Length); - } - return maxIndex == 1 ? "VALUE" : "VALUE" + (index + 1); - } - - private static string GetDescription (string description) - { - if (description == null) - return string.Empty; - StringBuilder sb = new StringBuilder (description.Length); - int start = -1; - for (int i = 0; i < description.Length; ++i) { - switch (description [i]) { - case '{': - if (i == start) { - sb.Append ('{'); - start = -1; - } - else if (start < 0) - start = i + 1; - break; - case '}': - if (start < 0) { - if ((i+1) == description.Length || description [i+1] != '}') - throw new InvalidOperationException ("Invalid option description: " + description); - ++i; - sb.Append ("}"); - } - else { - sb.Append (description.Substring (start, i - start)); - start = -1; - } - break; - case ':': - if (start < 0) - goto default; - start = i + 1; - break; - default: - if (start < 0) - sb.Append (description [i]); - break; - } - } - return sb.ToString (); - } - - private static IEnumerable GetLines (string description) - { - if (string.IsNullOrEmpty (description)) { - yield return string.Empty; - yield break; - } - int length = 80 - OptionWidth - 1; - int start = 0, end; - do { - end = GetLineEnd (start, length, description); - char c = description [end-1]; - if (char.IsWhiteSpace (c)) - --end; - bool writeContinuation = end != description.Length && !IsEolChar (c); - string line = description.Substring (start, end - start) + - (writeContinuation ? "-" : ""); - yield return line; - start = end; - if (char.IsWhiteSpace (c)) - ++start; - length = 80 - OptionWidth - 2 - 1; - } while (end < description.Length); - } - - private static bool IsEolChar (char c) - { - return !char.IsLetterOrDigit (c); - } - - private static int GetLineEnd (int start, int length, string description) - { - int end = System.Math.Min (start + length, description.Length); - int sep = -1; - for (int i = start; i < end; ++i) { - if (description [i] == '\n') - return i+1; - if (IsEolChar (description [i])) - sep = i+1; - } - if (sep == -1 || end == description.Length) - return end; - return sep; - } - } -} - From 121bb3e3205f27205b026fda229f0fd2618a4d92 Mon Sep 17 00:00:00 2001 From: Hylke Bons Date: Mon, 6 Feb 2012 14:11:08 +0100 Subject: [PATCH 11/17] Clean up and remove unneeded references --- SparkleLib/Git/SparkleRepoGit.cs | 2 -- SparkleLib/SparkleAnnouncement.cs | 1 - SparkleLib/SparkleFetcherBase.cs | 2 -- SparkleLib/SparkleListenerFactory.cs | 2 +- SparkleLib/SparkleRepoBase.cs | 1 - 5 files changed, 1 insertion(+), 7 deletions(-) diff --git a/SparkleLib/Git/SparkleRepoGit.cs b/SparkleLib/Git/SparkleRepoGit.cs index fa654c88..0c25ed24 100755 --- a/SparkleLib/Git/SparkleRepoGit.cs +++ b/SparkleLib/Git/SparkleRepoGit.cs @@ -17,10 +17,8 @@ using System; using System.Collections.Generic; -using System.Diagnostics; using System.IO; using System.Text.RegularExpressions; -using System.Xml; namespace SparkleLib { diff --git a/SparkleLib/SparkleAnnouncement.cs b/SparkleLib/SparkleAnnouncement.cs index a05068b7..9ec5cf56 100644 --- a/SparkleLib/SparkleAnnouncement.cs +++ b/SparkleLib/SparkleAnnouncement.cs @@ -16,7 +16,6 @@ using System; -using System.Collections.Generic; namespace SparkleLib { diff --git a/SparkleLib/SparkleFetcherBase.cs b/SparkleLib/SparkleFetcherBase.cs index da7ce962..276fa3a1 100755 --- a/SparkleLib/SparkleFetcherBase.cs +++ b/SparkleLib/SparkleFetcherBase.cs @@ -16,9 +16,7 @@ using System; -using System.Diagnostics; using System.IO; -using System.Security.AccessControl; using System.Text.RegularExpressions; using System.Threading; diff --git a/SparkleLib/SparkleListenerFactory.cs b/SparkleLib/SparkleListenerFactory.cs index e4021c29..6da29c35 100644 --- a/SparkleLib/SparkleListenerFactory.cs +++ b/SparkleLib/SparkleListenerFactory.cs @@ -44,7 +44,7 @@ namespace SparkleLib { // folder identifier, a SHA-1 hash) for when it's time to sync. // Clients also send the current revision hash to the channel // for other clients to pick up when you've synced up any - // changes. This way + // changes. // // Please see the SparkleShare wiki if you wish to run // your own service instead diff --git a/SparkleLib/SparkleRepoBase.cs b/SparkleLib/SparkleRepoBase.cs index 2d3c2c17..d670a14c 100755 --- a/SparkleLib/SparkleRepoBase.cs +++ b/SparkleLib/SparkleRepoBase.cs @@ -23,7 +23,6 @@ using System.Text; using System.Text.RegularExpressions; using System.Threading; using System.Timers; -using System.Xml; namespace SparkleLib { From e50ad79f92f36a9f328140c39e0fc209220cca67 Mon Sep 17 00:00:00 2001 From: Hylke Bons Date: Mon, 6 Feb 2012 14:40:48 +0100 Subject: [PATCH 12/17] Remove SparkleBackend crap --- SparkleLib/Git/SparkleGit.cs | 41 ++++++++++++-- SparkleLib/SparkleBackend.cs | 77 +-------------------------- SparkleShare/Mac/SparkleController.cs | 2 +- SparkleShare/SparkleControllerBase.cs | 7 --- 4 files changed, 39 insertions(+), 88 deletions(-) diff --git a/SparkleLib/Git/SparkleGit.cs b/SparkleLib/Git/SparkleGit.cs index 88199245..d2989268 100644 --- a/SparkleLib/Git/SparkleGit.cs +++ b/SparkleLib/Git/SparkleGit.cs @@ -16,6 +16,7 @@ using System; +using System.IO; using System.Diagnostics; namespace SparkleLib { @@ -23,27 +24,57 @@ namespace SparkleLib { public class SparkleGit : Process { public static string ExecPath = null; + public static string Path = null; public SparkleGit (string path, string args) : base () { + Path = LocateGit (); + EnableRaisingEvents = true; - StartInfo.FileName = SparkleBackend.DefaultBackend.Path; + StartInfo.FileName = Path; StartInfo.RedirectStandardOutput = true; StartInfo.UseShellExecute = false; StartInfo.WorkingDirectory = path; - if (!string.IsNullOrEmpty (ExecPath)) - StartInfo.Arguments = "--exec-path=\"" + ExecPath + "\" " + args; - else + if (string.IsNullOrEmpty (ExecPath)) StartInfo.Arguments = args; + else + StartInfo.Arguments = "--exec-path=\"" + ExecPath + "\" " + args; } new public void Start () { SparkleHelpers.DebugInfo ("Cmd", "git " + StartInfo.Arguments); - base.Start (); + + try { + base.Start (); + + } catch (Exception e) { + SparkleHelpers.DebugInfo ("Cmd", "There's a problem running Git: " + e.Message); + Environment.Exit (-1); + } + } + + + private string LocateGit () + { + if (!string.IsNullOrEmpty (Path)) + return Path; + + string [] possible_git_paths = new string [] { + "/usr/bin/git", + "/usr/local/bin/git", + "/opt/local/bin/git", + "/usr/local/git/bin/git" + }; + + foreach (string path in possible_git_paths) + if (File.Exists (path)) + return path; + + return "git"; } } } diff --git a/SparkleLib/SparkleBackend.cs b/SparkleLib/SparkleBackend.cs index c916fa83..8efe332c 100755 --- a/SparkleLib/SparkleBackend.cs +++ b/SparkleLib/SparkleBackend.cs @@ -21,40 +21,7 @@ using System.Runtime.InteropServices; namespace SparkleLib { - public class SparkleBackend { - - public static SparkleBackend DefaultBackend = new SparkleBackendGit (); - - public string Name; - public string Path; - - - public SparkleBackend (string name, string [] paths) - { - Name = name; - Path = "git"; - - foreach (string path in paths) { - if (File.Exists (path)) { - Path = path; - break; - } - } - } - - - public bool IsPresent { - get { - return (Path != null); - } - } - - - public bool IsUsablePath (string path) - { - return (path.Length > 0); - } - + public static class SparkleBackend { public static string Version { get { @@ -65,7 +32,7 @@ namespace SparkleLib { // Strange magic needed by Platform () [DllImport ("libc")] - static extern int uname (IntPtr buf); + private static extern int uname (IntPtr buf); // This fixes the PlatformID enumeration for MacOSX in Environment.OSVersion.Platform, @@ -90,44 +57,4 @@ namespace SparkleLib { } } } - - - public class SparkleBackendGit : SparkleBackend { - - private static string name = "Git"; - private static string [] paths = new string [] { - "/opt/local/bin/git", - "/usr/bin/git", - "/usr/local/bin/git", - "/usr/local/git/bin/git" - }; - - public SparkleBackendGit () : base (name, paths) { } - - } - - - public class SparkleBackendHg : SparkleBackend { - - private static string name = "Hg"; - private static string [] paths = new string [] { - "/opt/local/bin/hg", - "/usr/bin/hg" - }; - - public SparkleBackendHg () : base (name, paths) { } - - } - - - public class SparkleBackendScp : SparkleBackend { - - private static string name = "Scp"; - private static string [] paths = new string [] { - "/usr/bin/scp" - }; - - public SparkleBackendScp () : base (name, paths) { } - - } } diff --git a/SparkleShare/Mac/SparkleController.cs b/SparkleShare/Mac/SparkleController.cs index 9c9b0669..e32befef 100755 --- a/SparkleShare/Mac/SparkleController.cs +++ b/SparkleShare/Mac/SparkleController.cs @@ -54,7 +54,7 @@ namespace SparkleShare { // Let's use the bundled git first - SparkleBackend.DefaultBackend.Path = + SparkleGit.Path = Path.Combine (NSBundle.MainBundle.ResourcePath, "git", "libexec", "git-core", "git"); diff --git a/SparkleShare/SparkleControllerBase.cs b/SparkleShare/SparkleControllerBase.cs index 081f40da..b0b45403 100755 --- a/SparkleShare/SparkleControllerBase.cs +++ b/SparkleShare/SparkleControllerBase.cs @@ -782,13 +782,6 @@ namespace SparkleShare { } - public bool BackendIsPresent { - get { - return SparkleBackend.DefaultBackend.IsPresent; - } - } - - // Looks up the user's name from the global configuration public string UserName { From 0e3813c7ba6241461b294822759667036a223d5e Mon Sep 17 00:00:00 2001 From: Hylke Bons Date: Mon, 6 Feb 2012 14:53:02 +0100 Subject: [PATCH 13/17] controller: remove obsolete event --- SparkleShare/SparkleControllerBase.cs | 7 +------ SparkleShare/SparkleUI.cs | 5 +---- 2 files changed, 2 insertions(+), 10 deletions(-) diff --git a/SparkleShare/SparkleControllerBase.cs b/SparkleShare/SparkleControllerBase.cs index b0b45403..42015f71 100755 --- a/SparkleShare/SparkleControllerBase.cs +++ b/SparkleShare/SparkleControllerBase.cs @@ -40,9 +40,6 @@ namespace SparkleShare { public double ProgressPercentage = 0.0; public string ProgressSpeed = ""; - public event OnQuitWhileSyncingHandler OnQuitWhileSyncing; - public delegate void OnQuitWhileSyncingHandler (); - public event FolderFetchedEventHandler FolderFetched; public delegate void FolderFetchedEventHandler (string [] warnings); @@ -776,6 +773,7 @@ namespace SparkleShare { process.StartInfo.UseShellExecute = false; process.StartInfo.FileName = "ssh-add"; process.StartInfo.Arguments = "\"" + key_file_path + "\""; + process.StartInfo.CreateNoWindow = true; process.Start (); process.WaitForExit (); @@ -1107,9 +1105,6 @@ namespace SparkleShare { repo.Status == SyncStatus.SyncDown || repo.IsBuffering) { - if (OnQuitWhileSyncing != null) - OnQuitWhileSyncing (); - return; } } diff --git a/SparkleShare/SparkleUI.cs b/SparkleShare/SparkleUI.cs index 96ec23f2..deb387da 100755 --- a/SparkleShare/SparkleUI.cs +++ b/SparkleShare/SparkleUI.cs @@ -63,12 +63,9 @@ namespace SparkleShare { Setup = new SparkleSetup (); Setup.Controller.ShowSetupPage (); } - - Program.Controller.OnQuitWhileSyncing += delegate { - // TODO: Pop up a warning when quitting whilst syncing - }; } + // Runs the application public void Run () { From e706079ed1d11ad93757dd710a3eaf3220fba1c8 Mon Sep 17 00:00:00 2001 From: Hylke Bons Date: Mon, 6 Feb 2012 14:58:43 +0100 Subject: [PATCH 14/17] repo: set stricter access rights for members --- SparkleLib/SparkleRepoBase.cs | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/SparkleLib/SparkleRepoBase.cs b/SparkleLib/SparkleRepoBase.cs index d670a14c..194681ef 100755 --- a/SparkleLib/SparkleRepoBase.cs +++ b/SparkleLib/SparkleRepoBase.cs @@ -40,21 +40,21 @@ namespace SparkleLib { private TimeSpan long_interval = new TimeSpan (0, 0, 10, 0); private SparkleWatcher watcher; + private SparkleListenerBase listener; private TimeSpan poll_interval; private System.Timers.Timer local_timer = new System.Timers.Timer () { Interval = 0.25 * 1000 }; private System.Timers.Timer remote_timer = new System.Timers.Timer () { Interval = 10 * 1000 }; - private DateTime last_poll = DateTime.Now; - private List size_buffer = new List (); - private bool has_changed = false; - private Object change_lock = new Object (); - private Object watch_lock = new Object (); - private double progress_percentage = 0.0; - private string progress_speed = ""; + private DateTime last_poll = DateTime.Now; + private List size_buffer = new List (); + private bool has_changed = false; + private Object change_lock = new Object (); + private Object watch_lock = new Object (); + private double progress_percentage = 0.0; + private string progress_speed = ""; + private SyncStatus status; - protected SparkleListenerBase listener; - protected SyncStatus status; - protected bool is_buffering = false; - protected bool server_online = true; + private bool is_buffering = false; + private bool server_online = true; public readonly string LocalPath; public readonly string Name; From 7a0527b7a71ce7c1e9b93ecd3a932bb3d23570d2 Mon Sep 17 00:00:00 2001 From: Hylke Bons Date: Mon, 6 Feb 2012 15:02:41 +0100 Subject: [PATCH 15/17] repo: change CheckForRemoteChanges method to HasRemoteChanges property --- SparkleLib/Git/SparkleRepoGit.cs | 36 ++++++++++++++++++-------------- SparkleLib/SparkleRepoBase.cs | 13 ++++-------- 2 files changed, 24 insertions(+), 25 deletions(-) diff --git a/SparkleLib/Git/SparkleRepoGit.cs b/SparkleLib/Git/SparkleRepoGit.cs index 0c25ed24..35851dca 100755 --- a/SparkleLib/Git/SparkleRepoGit.cs +++ b/SparkleLib/Git/SparkleRepoGit.cs @@ -165,25 +165,29 @@ namespace SparkleLib { } - public override bool CheckForRemoteChanges () + public override bool HasRemoteChanges { - SparkleHelpers.DebugInfo ("Git", "[" + Name + "] Checking for remote changes..."); - SparkleGit git = new SparkleGit (LocalPath, "ls-remote " + Url + " master"); + get { + SparkleHelpers.DebugInfo ("Git", "[" + Name + "] Checking for remote changes..."); + SparkleGit git = new SparkleGit (LocalPath, "ls-remote " + Url + " master"); + + git.Start (); + git.WaitForExit (); + + if (git.ExitCode != 0) + return false; + + string remote_revision = git.StandardOutput.ReadToEnd ().TrimEnd (); + + if (!remote_revision.StartsWith (CurrentRevision)) { + SparkleHelpers.DebugInfo ("Git", + "[" + Name + "] Remote changes found. (" + remote_revision + ")"); - git.Start (); - git.WaitForExit (); + return true; - if (git.ExitCode != 0) - return false; - - string remote_revision = git.StandardOutput.ReadToEnd ().TrimEnd (); - - if (!remote_revision.StartsWith (CurrentRevision)) { - SparkleHelpers.DebugInfo ("Git", "[" + Name + "] Remote changes found. (" + remote_revision + ")"); - return true; - - } else { - return false; + } else { + return false; + } } } diff --git a/SparkleLib/SparkleRepoBase.cs b/SparkleLib/SparkleRepoBase.cs index 194681ef..021a0298 100755 --- a/SparkleLib/SparkleRepoBase.cs +++ b/SparkleLib/SparkleRepoBase.cs @@ -67,6 +67,7 @@ namespace SparkleLib { public abstract bool SyncDown (); public abstract double CalculateSize (DirectoryInfo parent); public abstract bool HasUnsyncedChanges { get; set; } + public abstract bool HasRemoteChanges { get; } public abstract List ExcludePaths { get; } public abstract double Size { get; } @@ -120,7 +121,7 @@ namespace SparkleLib { if (time_to_poll) { this.last_poll = DateTime.Now; - if (CheckForRemoteChanges ()) + if (HasRemoteChanges) SyncDownBase (); } @@ -210,12 +211,6 @@ namespace SparkleLib { } - public virtual bool CheckForRemoteChanges () // TODO: HasRemoteChanges { get; } - { - return true; - } - - public virtual List GetChangeSets (int count) { return null; } @@ -269,7 +264,7 @@ namespace SparkleLib { this.poll_interval = this.long_interval; new Thread (new ThreadStart (delegate { - if (!IsSyncing && CheckForRemoteChanges ()) + if (!IsSyncing && HasRemoteChanges) SyncDownBase (); })).Start (); } @@ -282,7 +277,7 @@ namespace SparkleLib { if (!IsSyncing) { // Check for changes manually one more time - if (CheckForRemoteChanges ()) + if (HasRemoteChanges) SyncDownBase (); // Push changes that were made since the last disconnect From e9373b87d5ab36fd865f05f7a94fa15886f174be Mon Sep 17 00:00:00 2001 From: Hylke Bons Date: Wed, 8 Feb 2012 01:44:56 +0100 Subject: [PATCH 16/17] Fix ping on timeout. Fixes broken reconnect --- SparkleLib/SparkleListenerBase.cs | 1 + SparkleLib/SparkleListenerTcp.cs | 47 +++++++++++++------------------ SparkleLib/SparkleRepoBase.cs | 1 + 3 files changed, 22 insertions(+), 27 deletions(-) diff --git a/SparkleLib/SparkleListenerBase.cs b/SparkleLib/SparkleListenerBase.cs index 8c20f850..89e1406b 100755 --- a/SparkleLib/SparkleListenerBase.cs +++ b/SparkleLib/SparkleListenerBase.cs @@ -105,6 +105,7 @@ namespace SparkleLib { } + // TODO: rename override method instead? public void AlsoListenToBase (string channel) { if (!this.channels.Contains (channel) && IsConnected) { diff --git a/SparkleLib/SparkleListenerTcp.cs b/SparkleLib/SparkleListenerTcp.cs index 5a6734f4..8bffe2f0 100755 --- a/SparkleLib/SparkleListenerTcp.cs +++ b/SparkleLib/SparkleListenerTcp.cs @@ -25,10 +25,11 @@ namespace SparkleLib { public class SparkleListenerTcp : SparkleListenerBase { private Socket socket; - private Object socket_lock = new Object (); private Thread thread; - private bool is_connected = false; - private bool is_connecting = false; + private Object socket_lock = new Object (); + private bool is_connected = false; + private bool is_connecting = false; + private int receive_timeout = 180 * 1000; public SparkleListenerTcp (Uri server, string folder_identifier) : @@ -56,8 +57,6 @@ namespace SparkleLib { // Starts a new thread and listens to the channel public override void Connect () { - SparkleHelpers.DebugInfo ("ListenerTcp", "Connecting to " + Server.Host); - this.is_connecting = true; this.thread = new Thread ( @@ -72,8 +71,8 @@ namespace SparkleLib { this.socket = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp) { - ReceiveTimeout = 60 * 1000, - SendTimeout = 3 * 1000 + ReceiveTimeout = this.receive_timeout, + SendTimeout = 10 * 1000 }; // Try to connect to the server @@ -87,7 +86,7 @@ namespace SparkleLib { // Subscribe to channels of interest to us foreach (string channel in base.channels) { SparkleHelpers.DebugInfo ("ListenerTcp", - "Subscribing to channel " + channel); + "Subscribing to channel " + channel + " on " + Server); byte [] subscribe_bytes = Encoding.UTF8.GetBytes ("subscribe " + channel + "\n"); @@ -116,40 +115,34 @@ namespace SparkleLib { // We've timed out, let's ping the server to // see if the connection is still up - } catch (SocketException e) { - - Console.WriteLine ("1st catch block"); - + } catch (SocketException) { try { - byte [] ping_bytes = - Encoding.UTF8.GetBytes ("ping"); + byte [] ping_bytes = Encoding.UTF8.GetBytes ("ping\n"); + byte [] ping_back_bytes = new byte [4096]; - Console.WriteLine ("1"); + SparkleHelpers.DebugInfo ("ListenerTcp", "Pinging " + Server); - this.socket.Send (ping_bytes); - this.socket.ReceiveTimeout = 3 * 1000; + lock (this.socket_lock) + this.socket.Send (ping_bytes); - Console.WriteLine ("2"); + this.socket.ReceiveTimeout = 10 * 1000; // 10057 means "Socket is not connected" - if (this.socket.Receive (bytes) < 1) { - Console.WriteLine ("3"); + if (this.socket.Receive (ping_back_bytes) < 1) throw new SocketException (10057); - } - Console.WriteLine ("4"); + SparkleHelpers.DebugInfo ("ListenerTcp", "Received pong from " + Server); + this.socket.ReceiveTimeout = this.receive_timeout; // The ping failed: disconnect completely } catch (SocketException) { this.is_connected = false; this.is_connecting = false; - this.socket.ReceiveTimeout = 60 * 1000; + this.socket.ReceiveTimeout = this.receive_timeout; - Console.WriteLine ("2nd catch block"); - - OnDisconnected (e.Message); - break; + OnDisconnected ("Ping timeout"); + return; } } diff --git a/SparkleLib/SparkleRepoBase.cs b/SparkleLib/SparkleRepoBase.cs index 021a0298..2afca945 100755 --- a/SparkleLib/SparkleRepoBase.cs +++ b/SparkleLib/SparkleRepoBase.cs @@ -191,6 +191,7 @@ namespace SparkleLib { public string Domain { get { + // TODO: use Uri class Regex regex = new Regex (@"(@|://)([a-z0-9\.-]+)(/|:)"); Match match = regex.Match (SparkleConfig.DefaultConfig.GetUrlForFolder (Name)); From bed669fd7796db273da06d7f1ca10413b13da4c8 Mon Sep 17 00:00:00 2001 From: Hylke Bons Date: Wed, 8 Feb 2012 02:17:34 +0100 Subject: [PATCH 17/17] listener: detect when system has woken up from sleep. disconnect when that happens --- SparkleLib/SparkleListenerTcp.cs | 40 ++++++++++++++++++++++++-------- 1 file changed, 30 insertions(+), 10 deletions(-) diff --git a/SparkleLib/SparkleListenerTcp.cs b/SparkleLib/SparkleListenerTcp.cs index 8bffe2f0..e70f5441 100755 --- a/SparkleLib/SparkleListenerTcp.cs +++ b/SparkleLib/SparkleListenerTcp.cs @@ -104,8 +104,9 @@ namespace SparkleLib { } - byte [] bytes = new byte [4096]; - int bytes_read = 0; + byte [] bytes = new byte [4096]; + int bytes_read = 0; + DateTime last_ping = DateTime.Now; // Wait for messages while (this.is_connected) { @@ -117,32 +118,51 @@ namespace SparkleLib { // see if the connection is still up } catch (SocketException) { try { - byte [] ping_bytes = Encoding.UTF8.GetBytes ("ping\n"); - byte [] ping_back_bytes = new byte [4096]; + // Check when the last ping occured. If it's + // significantly longer than our regular interval the + // system likely woke up from sleep and we want to + // simulate a disconnect + int sleepiness = DateTime.Compare ( + last_ping.AddMilliseconds (this.receive_timeout * 1.25), + DateTime.Now + ); + + if (sleepiness <= 0) { + // 10057 means "Socket is not connected" + Console.WriteLine ("SLEEP OCCURED"); + throw new SocketException (10057); + } + SparkleHelpers.DebugInfo ("ListenerTcp", "Pinging " + Server); + byte [] ping_bytes = Encoding.UTF8.GetBytes ("ping\n"); + byte [] pong_bytes = new byte [4096]; + lock (this.socket_lock) this.socket.Send (ping_bytes); + this.socket.ReceiveTimeout = 10 * 1000; - // 10057 means "Socket is not connected" - if (this.socket.Receive (ping_back_bytes) < 1) + if (this.socket.Receive (pong_bytes) < 1) + // 10057 means "Socket is not connected" throw new SocketException (10057); SparkleHelpers.DebugInfo ("ListenerTcp", "Received pong from " + Server); + + this.socket.ReceiveTimeout = this.receive_timeout; + last_ping = DateTime.Now; // The ping failed: disconnect completely } catch (SocketException) { - this.is_connected = false; - this.is_connecting = false; - + this.is_connected = false; + this.is_connecting = false; this.socket.ReceiveTimeout = this.receive_timeout; OnDisconnected ("Ping timeout"); - return; + break; } }