Esempio n. 1
0
        //private:
        ListViewItem CreateItem(IUpdateAction action)
        {
            switch (action.Code)
            {
            case ActionCode_t.ResetTable:
                return(new ListViewItem(m_actionsName[ActionCode_t.ResetTable]));

            case ActionCode_t.DeleteRow:
            {
                var delRow = action as DeleteRow;
                return(new ListViewItem(new[] { m_actionsName[ActionCode_t.DeleteRow], delRow.RowID.ToString() }));
            }

            case ActionCode_t.ReplaceRow:
            {
                var repRow = action as ReplaceRow;
                return(new ListViewItem(new[] { m_actionsName[ActionCode_t.ReplaceRow], repRow.RowID.ToString() }));
            }

            case ActionCode_t.AddRow:
            {
                var addRow = action as AddRow;
                return(new ListViewItem(new[] { m_actionsName[ActionCode_t.AddRow], addRow.Datum.ID.ToString() }));
            }

            default:
                Assert(false);
                break;
            }

            return(null);
        }
Esempio n. 2
0
 /// <summary>
 ///     Updates the state of the game with the current action.
 /// </summary>
 /// <param name="action">The action to be played by the current player</param>
 /// <exception cref="ArgumentException">
 ///     If the move is invalid. The action's validity should be verified upstream.
 /// </exception>
 public void Update(IUpdateAction action)
 {
     lock (_syncLock) {
         if (action.IsValidOn(State))
         {
             Memento = Memento.Update(action);
             _breadCrumbs.Clear();
         }
         else
         {
             throw new ArgumentException("Invalid move: " + action);
         }
     }
 }
Esempio n. 3
0
        public static void Using <TEvent, TKey, TProjection, TContext>(
            this IUpdateAction <TEvent, TKey, TProjection, TContext> action,
            Func <TProjection, TEvent, Task> projector)
        {
            if (action == null)
            {
                throw new ArgumentNullException(nameof(action));
            }

            if (projector == null)
            {
                throw new ArgumentNullException(nameof(projector));
            }

            action.Using((projection, anEvent, context) => projector(projection, anEvent));
        }
Esempio n. 4
0
        /// Updates the creation statistics of moves
        private static IUpdateAction UpdateStatisticsAndPass(this IUpdateAction action)
        {
            switch (action)
            {
            case MoveBallAction moveBallAction:
                MoveBalls++;
                break;

            case MovePieceAction movePieceAction:
                MovePieces++;
                break;

            case PassAction passAction:
                Passes++;
                break;
            }
            return(action);
        }
Esempio n. 5
0
        public static void Using <TEvent, TKey, TProjection, TContext>(
            this IUpdateAction <TEvent, TKey, TProjection, TContext> action,
            Action <TProjection, TEvent> projector)
        {
            if (action == null)
            {
                throw new ArgumentNullException(nameof(action));
            }

            if (projector == null)
            {
                throw new ArgumentNullException(nameof(projector));
            }

            action.Using((projection, anEvent, context) =>
            {
                projector(projection, anEvent);
                return(TaskConstants.FalseTask);
            });
        }
Esempio n. 6
0
        //private;
        static void ApplyAction(IUpdateAction action, DBKeyIndexer ndxer)
        {
            switch (action.Code)
            {
            case ActionCode_t.DeleteRow:
                var delAct = action as DeleteRow;
                ndxer.Source.Delete(ndxer.IndexOf(delAct.RowID));
                break;

            case ActionCode_t.ReplaceRow:
                var replaceAct = action as ReplaceRow;
                ndxer.Source.Replace(ndxer.IndexOf(replaceAct.RowID), replaceAct.Datum);
                break;

            case ActionCode_t.AddRow:
                var addAct = action as AddRow;
                ndxer.Source.Insert(addAct.Datum);
                break;

            default:
                Assert(false);
                break;
            }
        }
Esempio n. 7
0
 /// <summary>
 ///     Gets a new memento based on this one.
 /// </summary>
 /// <param name="action">The transition from this memento to the result</param>
 /// <returns>A new memento with this as its parent</returns>
 public MementoNode Update(IUpdateAction action)
 {
     return(new MementoNode(this, action));
 }
Esempio n. 8
0
 public MementoNode(GameMemento previous, IUpdateAction action) : base(previous)
 {
     Action = action;
 }
Esempio n. 9
0
 public ActionInfo(IUpdateAction action, int szDatum)
 {
     Action    = action;
     DatumSize = szDatum;
 }
Esempio n. 10
0
 public void Add(IUpdateAction item) => Items.Add(item);
Esempio n. 11
0
        private static void Main()
        {
            //Debugger.Launch();
            try
            {
                // Get the update process name, to be used to create a named pipe and to wait on the application
                // to quit
                string[] args            = Environment.GetCommandLineArgs();
                string   syncProcessName = args[1];

                if (string.IsNullOrEmpty(syncProcessName))
                {
                    Application.Exit();
                }

                // Connect to the named pipe and retrieve the updates list
                var PIPE_NAME = string.Format("\\\\.\\pipe\\{0}", syncProcessName);
                var o         = GetUpdates(PIPE_NAME);

                // Make sure we start updating only once the application has completely terminated
                bool createdNew;
                using (var mutex = new Mutex(false, syncProcessName, out createdNew))
                {
                    try
                    {
                        if (!createdNew)
                        {
                            mutex.WaitOne();
                        }
                    }
                    catch (AbandonedMutexException)
                    {
                        // An abandoned mutex is exactly what we are expecting...
                    }
                }

                string appPath, appDir, tempFolder, backupFolder;
                bool   relaunchApp = true, updateSuccessful = true;
                {
                    Dictionary <string, object> dict = null;
                    if (o is Dictionary <string, object> )
                    {
                        dict = o as Dictionary <string, object>;
                    }

                    if (dict == null || dict.Count == 0)
                    {
                        Application.Exit();
                        return;
                    }

                    // Get some required environment variables
                    appPath      = dict["ENV:AppPath"].ToString();
                    appDir       = dict["ENV:WorkingDirectory"] as string ?? Path.GetDirectoryName(appPath);
                    tempFolder   = dict["ENV:TempFolder"].ToString();
                    backupFolder = dict["ENV:BackupFolder"].ToString();
                    relaunchApp  = dict["ENV:RelaunchApplication"] as bool? ?? true;

                    // Perform the actual off-line update process
                    var en = dict.GetEnumerator();
                    while (en.MoveNext())
                    {
                        if (en.Current.Key.StartsWith("ENV:"))
                        {
                            continue;
                        }
                        else
                        {
                            IUpdateAction a = null;
                            if (en.Current.Value is string)
                            {
                                a = new FileCopyAction(en.Current.Value.ToString(), Path.Combine(appDir, en.Current.Key));
                            }
                            else if (en.Current.Value is byte[])
                            {
                                a = new FileDumpAction(Path.Combine(appDir, en.Current.Key), (byte[])en.Current.Value);
                            }

                            if (a != null)
                            {
                                try
                                {
                                    if (!a.Do())
                                    {
                                        updateSuccessful = false;
                                        break;
                                    }
                                }
                                catch (Exception e)
                                {
                                    MessageBox.Show("Update failed: " + e.Message);
                                    updateSuccessful = false;
                                    break;
                                }
                            }
                        }
                    }
                }

                if (updateSuccessful)
                {
                    if (Directory.Exists(backupFolder))
                    {
                        Directory.Delete(backupFolder, true);
                    }
                }
                else
                {
                    MessageBox.Show("Update Failed.");
                }

                // Start the application only if requested to do so
                if (relaunchApp)
                {
                    try
                    {
                        Process.Start(new ProcessStartInfo
                        {
                            UseShellExecute  = true,
                            WorkingDirectory = appDir,
                            FileName         = appPath,
                        });
                    } catch (Win32Exception e) {
                        MessageBox.Show(e.ToString());
                    }
                }

                //MessageBox.Show(string.Format("Re-launched process {0} with working dir {1}", appPath, appDir));

                // Delete the updater EXE and the temp folder)
                try
                {
                    var Info = new ProcessStartInfo();
                    //Application.ExecutablePath
                    Info.Arguments = string.Format(@"/C ping 1.1.1.1 -n 1 -w 3000 > Nul & echo Y|del ""{0}\*.*"" & rmdir ""{0}"""
                                                   , tempFolder);
                    Info.WindowStyle    = ProcessWindowStyle.Hidden;
                    Info.CreateNoWindow = true;
                    Info.FileName       = "cmd.exe";
                    Process.Start(Info);
                }
                catch { /* ignore exceptions thrown while trying to clean up */ }

                Application.Exit();
            }
            catch
            {
                //supressing catch because if at any point we get an error the update has failed
            }
            finally
            {
                Application.Exit();
            }
        }