Пример #1
0
        public SortedList<string, string> LoadScripts(string path, string pattern, bool recurse, string workingDirectory, Versioning.IParseVersions versionParser = null)
        {
            SortedList<string, string> s = ScriptRunner.ResolveScriptsFromPathAndVersion(path, pattern, recurse, workingDirectory, FromVersion,
                                                          ToVersion, versionParser);

            return s;
        }
Пример #2
0
 private void UpdateVersionAfterPatch(int verNumber)
 {
     Versioning.SetNewVersionAfterPatch(verNumber);
     if (!Dispatcher.CheckAccess())
     {
         Dispatcher.Invoke(() => GameVersionLabel.Content = Versioning.FriendlyCurrentGameVersion());
     }
     else
     {
         GameVersionLabel.Content = Versioning.FriendlyCurrentGameVersion();
     }
 }
Пример #3
0
 /// <summary>
 /// Creates a new instance of the TcpDuplexServerProtocolSetup class.
 /// </summary>
 /// <param name="versioning">Versioning behavior</param>
 /// <param name="tcpPort">TCP port number</param>
 /// <param name="authProvider">Authentication provider</param>
 /// <param name="encryption">Specifies if the communication sould be encrypted</param>
 /// <param name="algorithm">Encryption algorithm (e.G. "3DES")</param>
 /// <param name="oaep">Specifies if OAEP padding should be activated</param>
 /// <param name="keepAlive">Enables or disables TCP KeepAlive for the new connection</param>
 /// <param name="keepAliveTime">Time for TCP KeepAlive in Milliseconds</param>
 /// <param name="KeepAliveInterval">Interval for TCP KeepAlive in Milliseconds</param>
 public TcpDuplexServerProtocolSetup(Versioning versioning, int tcpPort, IAuthenticationProvider authProvider, bool encryption, string algorithm, bool oaep, bool keepAlive, ulong keepAliveTime, ulong KeepAliveInterval)
     : this(versioning)
 {
     TcpPort = tcpPort;
     AuthenticationProvider = authProvider;
     Encryption             = encryption;
     Algorithm            = algorithm;
     Oaep                 = oaep;
     TcpKeepAliveEnabled  = keepAlive;
     TcpKeepAliveTime     = keepAliveTime;
     TcpKeepAliveInterval = KeepAliveInterval;
 }
Пример #4
0
 private void DisplayRegistrationSuccessfullMessage(Versioning serverVersion)
 {
     AddServerMessage(ChatColor.Green, "*** You've registered successfully as {0} ({1})", Client.Name, Client.IsSpectator ? "Spectator" : "Player");
     if (serverVersion == null)
     {
         AddServerMessage(ChatColor.Red, "Unknown server version. Use at your own risk!!!");
     }
     else
     {
         AddServerMessage(ChatColor.Red, "Server version: {0}.{1}", serverVersion.Major, serverVersion.Minor);
     }
 }
Пример #5
0
 private void OnRegisteredAsPlayer(RegistrationResults result, Versioning serverVersion, int playerId, bool isServerMaster)
 {
     if (result == RegistrationResults.RegistrationSuccessful)
     {
         DisplayRegistrationSuccessfullMessage(serverVersion);
         IsRegistered = true;
     }
     else
     {
         DisplayRegistrationFailMessage(result, serverVersion);
     }
 }
Пример #6
0
 private void OnRegisteredAsSpectator(RegistrationResults result, Versioning serverVersion, int spectatorId)
 {
     if (result == RegistrationResults.RegistrationSuccessful)
     {
         DisplayRegistrationSuccessfullMessage(serverVersion);
         IsRegistered = true;
     }
     else
     {
         DisplayRegistrationFailMessage(result, serverVersion);
     }
 }
Пример #7
0
        private AirlinerCargoType(SerializationInfo info, StreamingContext ctxt)
            : base(info, ctxt)
        {
            int version = info.GetInt16("version");

            var fields = this.GetType().GetFields(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public).Where(p => p.GetCustomAttribute(typeof(Versioning)) != null);

            IList <PropertyInfo> props = new List <PropertyInfo>(this.GetType().GetProperties(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public).Where(p => p.GetCustomAttribute(typeof(Versioning)) != null));

            var propsAndFields = props.Cast <MemberInfo>().Union(fields.Cast <MemberInfo>());

            foreach (SerializationEntry entry in info)
            {
                MemberInfo prop = propsAndFields.FirstOrDefault(p => ((Versioning)p.GetCustomAttribute(typeof(Versioning))).Name == entry.Name);


                if (prop != null)
                {
                    if (prop is FieldInfo)
                    {
                        ((FieldInfo)prop).SetValue(this, entry.Value);
                    }
                    else
                    {
                        ((PropertyInfo)prop).SetValue(this, entry.Value);
                    }
                }
            }

            var notSetProps = propsAndFields.Where(p => ((Versioning)p.GetCustomAttribute(typeof(Versioning))).Version > version);

            foreach (MemberInfo notSet in notSetProps)
            {
                Versioning ver = (Versioning)notSet.GetCustomAttribute(typeof(Versioning));

                if (ver.AutoGenerated)
                {
                    if (notSet is FieldInfo)
                    {
                        ((FieldInfo)notSet).SetValue(this, ver.DefaultValue);
                    }
                    else
                    {
                        ((PropertyInfo)notSet).SetValue(this, ver.DefaultValue);
                    }
                }

                if (version == 1)
                {
                    this.IsConvertable = false;
                }
            }
        }
Пример #8
0
        public void UC_UpdateNuspecFile_Works()
        {
            b.Info.Flow();

            var    reid    = TestResources.GetIdentifiers(TestResourcesReferences.NuspecSample1);
            string srcFile = uth.GetTestDataFile(reid);

            MockVersionStorage mvs = new MockVersionStorage("0.0.0.1");
            Versioning         sut = new Versioning(mvs);

            sut.AddNugetFile(srcFile);
        }
Пример #9
0
        /// <summary>
        /// Creates a new instance of the TcpDuplexServerProtocolSetup class.
        /// </summary>
        /// <param name="versioning">Versioning behavior</param>
        public TcpDuplexServerProtocolSetup(Versioning versioning)
            : base((settings, clientSinkChain, serverSinkChain) => new TcpExChannel(settings, clientSinkChain, serverSinkChain))
        {
            _versioning = versioning;

            Hashtable formatterSettings = new Hashtable();
            formatterSettings.Add("includeVersions", _versioning == Versioning.Strict);
            formatterSettings.Add("strictBinding", _versioning == Versioning.Strict);

            ClientSinkChain.Add(new BinaryClientFormatterSinkProvider(formatterSettings, null));
            ServerSinkChain.Add(new BinaryServerFormatterSinkProvider(formatterSettings, null) { TypeFilterLevel = TypeFilterLevel.Full });
            ServerSinkChain.Add(new ClientAddressServerChannelSinkProvider());
        }
Пример #10
0
        private bool IsVersionIncrementRequired(FlushEntityEvent @event, EntityEntry entry, IEntityPersister persister, int[] dirtyProperties)
        {
            // NH different behavior: because NH-1756 when PostInsertId is used with a generated version
            // the version is read inmediately after save and does not need to be incremented.
            // BTW, in general, a generated version does not need to be incremented by NH.

            bool isVersionIncrementRequired =
                entry.Status != Status.Deleted && !persister.IsVersionPropertyGenerated &&
                (dirtyProperties == null ||
                 Versioning.IsVersionIncrementRequired(dirtyProperties, @event.HasDirtyCollection, persister.PropertyVersionability));

            return(isVersionIncrementRequired);
        }
Пример #11
0
        /// <summary>
        /// Perform any property value substitution that is necessary
        /// (interceptor callback, version initialization...)
        /// </summary>
        /// <param name="entity">The entity </param>
        /// <param name="id">The entity identifier </param>
        /// <param name="values">The snapshot entity state </param>
        /// <param name="persister">The entity persister </param>
        /// <param name="source">The originating session </param>
        /// <returns>
        /// True if the snapshot state changed such that
        /// reinjection of the values into the entity is required.
        /// </returns>
        protected virtual bool SubstituteValuesIfNecessary(object entity, object id, object[] values, IEntityPersister persister, ISessionImplementor source)
        {
            bool substitute = source.Interceptor.OnSave(entity, id, values, persister.PropertyNames, persister.PropertyTypes);

            //keep the existing version number in the case of replicate!
            if (persister.IsVersioned)
            {
                // NH Specific feature (H3.2 use null value for versionProperty; NH ask to persister to know if a valueType mean unversioned)
                object versionValue = values[persister.VersionProperty];
                substitute |= Versioning.SeedVersion(values, persister.VersionProperty, persister.VersionType, persister.IsUnsavedVersion(versionValue), source);
            }
            return(substitute);
        }
Пример #12
0
        /// <summary>
        /// Creates a new instance of the IpcBinaryClientProtocolSetup class.
        /// </summary>
        /// <param name="versioning">Versioning behavior</param>
        public IpcBinaryClientProtocolSetup(Versioning versioning)
            : base((settings, clientSinkChain, serverSinkChain) => new IpcChannel(settings, clientSinkChain, serverSinkChain))
        {
            _channelName = "IpcBinaryClientProtocol_" + Guid.NewGuid().ToString();
            _versioning = versioning;

            Hashtable formatterSettings = new Hashtable();
            formatterSettings.Add("includeVersions", _versioning == Versioning.Strict);
            formatterSettings.Add("strictBinding", _versioning == Versioning.Strict);

            ClientSinkChain.Add(new BinaryClientFormatterSinkProvider(formatterSettings, null));
            ServerSinkChain.Add(new BinaryServerFormatterSinkProvider(formatterSettings, null) { TypeFilterLevel = TypeFilterLevel.Full });
        }
Пример #13
0
        private object AssembleCacheEntry(CacheEntry entry, object id, IEntityPersister persister, LoadEvent @event)
        {
            object       optionalObject        = @event.InstanceToLoad;
            IEventSource session               = @event.Session;
            ISessionFactoryImplementor factory = session.Factory;

            if (log.IsDebugEnabled)
            {
                log.Debug("assembling entity from second-level cache: " + MessageHelper.InfoString(persister, id, factory));
            }

            IEntityPersister subclassPersister = factory.GetEntityPersister(entry.Subclass);
            object           result            = optionalObject ?? session.Instantiate(subclassPersister, id);

            // make it circular-reference safe
            TwoPhaseLoad.AddUninitializedCachedEntity(new EntityKey(id, subclassPersister, session.EntityMode), result, subclassPersister, LockMode.None, entry.AreLazyPropertiesUnfetched, entry.Version, session);

            IType[]  types  = subclassPersister.PropertyTypes;
            object[] values = entry.Assemble(result, id, subclassPersister, session.Interceptor, session);             // intializes result by side-effect
            TypeFactory.DeepCopy(values, types, subclassPersister.PropertyUpdateability, values, session);

            object version = Versioning.GetVersion(values, subclassPersister);

            if (log.IsDebugEnabled)
            {
                log.Debug("Cached Version: " + version);
            }

            IPersistenceContext persistenceContext = session.PersistenceContext;

            persistenceContext.AddEntry(result, Status.Loaded, values, null, id, version, LockMode.None, true, subclassPersister, false, entry.AreLazyPropertiesUnfetched);
            subclassPersister.AfterInitialize(result, entry.AreLazyPropertiesUnfetched, session);
            persistenceContext.InitializeNonLazyCollections();
            // upgrade the lock if necessary:
            //lock(result, lockMode);

            //PostLoad is needed for EJB3
            //TODO: reuse the PostLoadEvent...
            PostLoadEvent postLoadEvent = new PostLoadEvent(session);

            postLoadEvent.Entity    = result;
            postLoadEvent.Id        = id;
            postLoadEvent.Persister = persister;

            IPostLoadEventListener[] listeners = session.Listeners.PostLoadEventListeners;
            for (int i = 0; i < listeners.Length; i++)
            {
                listeners[i].OnPostLoad(postLoadEvent);
            }
            return(result);
        }
        private static NpmHistory FilterLatestVersions(NpmHistory history)
        {
            var filteredHistory = new NpmHistory
            {
                name        = history.name,
                description = history.description,
                versions    = new List <string>()
            };

            var firstVersion   = Versioning.StringToVersion(history.versions[0]);
            var currentMajor   = firstVersion.Major;
            var currentMinor   = firstVersion.Minor;
            var currentBuild   = firstVersion.Build;
            var currentVersion = history.versions[0];

            for (var i = 0; i < history.versions.Count; i++)
            {
                if (i == history.versions.Count - 1)
                {
                    filteredHistory.versions.Add(history.versions[i]);
                }

                var ver = Versioning.StringToVersion(history.versions[i]);

                if (ver.Major > currentMajor)
                {
                    currentMajor = ver.Major;
                    currentMinor = ver.Minor;
                    currentBuild = ver.Build;
                    filteredHistory.versions.Add(currentVersion);
                    currentVersion = history.versions[i];
                    continue;
                }

                if (ver.Minor > currentMinor)
                {
                    currentMinor = ver.Minor;
                    currentBuild = ver.Build;
                    filteredHistory.versions.Add(currentVersion);
                    currentVersion = history.versions[i];
                    continue;
                }

                if (ver.Build > currentBuild)
                {
                    currentVersion = history.versions[i];
                }
            }

            return(filteredHistory);
        }
Пример #15
0
        public static void NewPipelineBuild()
        {
            Save();

            Versioning.ClearConsole();

            SemVer.BumpPatch();

            AddressableAssetSettings.BuildPlayerContent();

            LoadResourceFile();

            OpenBuildFolder();
        }
        /// <summary>
        /// Perform any property value substitution that is necessary
        /// (interceptor callback, version initialization...)
        /// </summary>
        /// <param name="entity">The entity </param>
        /// <param name="id">The entity identifier </param>
        /// <param name="values">The snapshot entity state </param>
        /// <param name="persister">The entity persister </param>
        /// <param name="source">The originating session </param>
        /// <param name="cancellationToken">A cancellation token that can be used to cancel the work</param>
        /// <returns>
        /// True if the snapshot state changed such that
        /// reinjection of the values into the entity is required.
        /// </returns>
        protected virtual async Task <bool> SubstituteValuesIfNecessaryAsync(object entity, object id, object[] values, IEntityPersister persister, ISessionImplementor source, CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();
            bool substitute = source.Interceptor.OnSave(entity, id, values, persister.PropertyNames, persister.PropertyTypes);

            //keep the existing version number in the case of replicate!
            if (persister.IsVersioned)
            {
                // NH Specific feature (H3.2 use null value for versionProperty; NH ask to persister to know if a valueType mean unversioned)
                object versionValue = values[persister.VersionProperty];
                substitute |= await(Versioning.SeedVersionAsync(values, persister.VersionProperty, persister.VersionType, persister.IsUnsavedVersion(versionValue), source, cancellationToken)).ConfigureAwait(false);
            }
            return(substitute);
        }
Пример #17
0
        public override string GenerateDiffScript(DataModel previousModel, Versioning version)
        {
            if (previousModel == null)
            {
                throw new Exception("The previous model cannot be null.");
            }

            var sb = new StringBuilder();

            sb.AppendLine("--NOT IMPLEMENTED");
            sb.AppendLine("--Generated Upgrade For Version " + version.ToString());
            sb.AppendLine("--Generated on " + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
            return(sb.ToString());
        }
Пример #18
0
 public void OnPlayerRegistered(RegistrationResults result, Versioning serverVersion, int playerId, bool gameStarted, bool isServerMaster, GameOptions options)
 {
     Log.Default.WriteLine(LogLevels.Info, "OnPlayerRegistered[{0}]:{1} => {2} {3} {4} | Version: {5}.{6}", PlayerName, result, playerId, gameStarted, isServerMaster, serverVersion == null ? -1 : serverVersion.Major, serverVersion == null ? -1 : serverVersion.Minor);
     ResetTimeout();
     if (result == RegistrationResults.RegistrationSuccessful)
     {
         PlayerId = playerId;
         State    = States.WaitingStartGame;
     }
     else
     {
         State = States.ApplicationStarted;
     }
 }
        private void PreHandleUnitTestProjects(Dictionary <string, string> replacementsDictionary)
        {
            var  testProjectPicker = new TestProjectPicker();
            bool?result            = testProjectPicker.ShowModal();

            if (testProjectPicker.SelectedProject != null)
            {
                //TODO: Why am I doing this?
                Solution solution     = _dte.Solution;
                Project  project      = testProjectPicker.SelectedProject;
                string   path         = string.Empty;
                string   projectPath  = Path.GetDirectoryName(project.FullName);
                string   solutionPath = Path.GetDirectoryName(solution.FullName);
                if (!string.IsNullOrEmpty(projectPath) && !string.IsNullOrEmpty(solutionPath))
                {
                    if (projectPath.StartsWith(solutionPath))
                    {
                        path = "..\\" + project.UniqueName;
                    }
                    else
                    {
                        path = project.FullName;
                    }
                }

                replacementsDictionary["$referenceproject$"] = "True";
                replacementsDictionary.Add("$projectPath$", path);
                replacementsDictionary.Add("$projectId$", project.Kind);
                replacementsDictionary.Add("$projectName$", project.Name);
            }

            if (testProjectPicker.SelectedUnitTestFramework != null)
            {
                _unitTestFrameworkPackage = testProjectPicker.SelectedUnitTestFramework.NugetName;

                replacementsDictionary.Add("$useXrmToolingClientUsing$",
                                           testProjectPicker.SelectedUnitTestFramework.CrmMajorVersion >= 8 ? "1" : "0");
            }
            else
            {
                if (testProjectPicker.SelectedProject == null)
                {
                    return;
                }

                string version = ProjectWorker.GetSdkCoreVersion(testProjectPicker.SelectedProject);
                replacementsDictionary.Add("$useXrmToolingClientUsing$",
                                           Versioning.StringToVersion(version).Major >= 8 ? "1" : "0");
            }
        }
Пример #20
0
    //+-----------------------------------------------------------------------------------------------------
    //| g e t C u r r e n t V e r s i o n
    //+-----------------------------------------------------------------------------------------------------
    // Auteur: Jonathan Lapierre
    // Compagnie: Thoran inc.
    //
    /// <summary>
    /// Will give the current version of the file (Version flagged as active)
    /// </summary>
    /// <returns>Will return an empty version object if not found</returns>
    public Versioning getCurrentVersion()
    {
        try
        {
            //Check if the XML was already loaded, if not load it
            if (this.xmlConfig.InnerXml == "")
            {
                this.LoadFromFile();
            }

            //Loop the nodes to find the active version
            foreach (XmlNode MasterNodeFetch in xmlConfig.SelectNodes("/root/version"))
            {
                if (MasterNodeFetch.Attributes["active"].Value == "true")
                {
                    Versioning retVers = new Versioning();
                    retVers.Major           = MasterNodeFetch.Attributes["major"].Value;
                    retVers.Minor           = MasterNodeFetch.Attributes["minor"].Value;
                    retVers.Build           = MasterNodeFetch.Attributes["build"].Value;
                    retVers.VersionInfo     = MasterNodeFetch.ChildNodes[0].InnerText;
                    retVers.MajorMinorBuild = retVers.Major + "." + retVers.Minor + "." + retVers.Build;
                    retVers.CurrentVersion  = new System.Version(retVers.MajorMinorBuild);

                    DateTime ReleaseDate;

                    //Check if date is valid
                    if (DateTime.TryParse(MasterNodeFetch.Attributes["releaseDate"].Value, out ReleaseDate))
                    {
                        retVers.ReleaseDate = ReleaseDate;
                    }
                    else
                    {
                        retVers.ReleaseDate = DateTime.MinValue;
                    }

                    return(retVers);
                }
            }

            return(new Versioning());
        }
        catch (Exception err)
        {
            GlobalFuncLocal.log(err.Message + " | " + err.StackTrace, GlobalFuncLocal.ErrorLevel.CRITICAL);

            //Throw exception to let programmer or administrator know that their is a missing or invalid version.xml file
            throw new Exception("Missing or invalid version.xml file. Please check log for more information");
        }
    }
Пример #21
0
        public void Versioning_DefaultBehaviour_IsIncrementBuild()
        {
            b.Info.Flow();

            JsonVersionPersister jvp = new JsonVersionPersister(uth.NewTemporaryFileName(true));
            Versioning           ver = new Versioning(jvp);

            string before = ver.ToString();

            ver.Increment();
            string after = ver.ToString();

            Assert.Equal("0.0.0.0", before);
            Assert.Equal("0.0.1.0", after);
        }
Пример #22
0
        /// <summary>
        /// Creates a new instance of the TcpBinaryServerProtocolSetup class.
        /// </summary>
        /// <param name="versioning">Versioning behavior</param>
        public TcpBinaryServerProtocolSetup(Versioning versioning)
            : base((settings, clientSinkChain, serverSinkChain) => new TcpChannel(settings, clientSinkChain, serverSinkChain))
        {
            SocketCachingEnabled = true;
            _channelName = "TcpBinaryServerProtocolSetup_" + Guid.NewGuid().ToString();
            _versioning = versioning;

            Hashtable formatterSettings = new Hashtable();
            formatterSettings.Add("includeVersions", _versioning == Versioning.Strict);
            formatterSettings.Add("strictBinding", _versioning == Versioning.Strict);

            ClientSinkChain.Add(new BinaryClientFormatterSinkProvider(formatterSettings, null));
            ServerSinkChain.Add(new BinaryServerFormatterSinkProvider(formatterSettings, null) { TypeFilterLevel = TypeFilterLevel.Full });
            ServerSinkChain.Add(new ClientAddressServerChannelSinkProvider());
        }
Пример #23
0
        /// <summary>
        /// Creates a new instance of the TcpBinaryServerProtocolSetup class.
        /// </summary>
        /// <param name="versioning">Versioning behavior</param>
        public TcpBinaryServerProtocolSetup(Versioning versioning)
            : base((settings, clientSinkChain, serverSinkChain) => new TcpChannel(settings, clientSinkChain, serverSinkChain))
        {
            SocketCachingEnabled = true;
            _channelName = "TcpBinaryServerProtocolSetup_" + Guid.NewGuid().ToString();
            _versioning = versioning;

            Hashtable formatterSettings = new Hashtable();
            formatterSettings.Add("includeVersions", _versioning == Versioning.Strict);
            formatterSettings.Add("strictBinding", _versioning == Versioning.Strict);

            ClientSinkChain.Add(new SafeBinaryClientFormatterSinkProvider(formatterSettings, null));
            ServerSinkChain.Add(new SafeBinaryServerFormatterSinkProvider(formatterSettings, null) { TypeFilterLevel = TypeFilterLevel.Full });
            ServerSinkChain.Add(new ClientAddressServerChannelSinkProvider());
        }
Пример #24
0
        /// <summary>
        /// Creates a new instance of the HttpCustomClientProtocolSetup class.
        /// </summary>
        /// <param name="versioning">Versioning behavior</param>
        /// <param name="webProxy">Defines HTTP proxy settings</param>
        public HttpCustomClientProtocolSetup(Versioning versioning, IWebProxy webProxy)
            : base((settings, clientSinkChain, serverSinkChain) => new HttpChannel(settings, clientSinkChain, serverSinkChain))
        {
            _channelName = "HttpCustomClientProtocolSetup" + Guid.NewGuid().ToString();
            _versioning = versioning;

            Hashtable formatterSettings = new Hashtable();
            formatterSettings.Add("includeVersions", _versioning == Versioning.Strict);
            formatterSettings.Add("strictBinding", _versioning == Versioning.Strict);

            WebRequest.DefaultWebProxy = webProxy;

            ClientSinkChain.Add(new BinaryClientFormatterSinkProvider(formatterSettings, null));
            ServerSinkChain.Add(new BinaryServerFormatterSinkProvider(formatterSettings, null) { TypeFilterLevel = TypeFilterLevel.Full });
        }
Пример #25
0
 private void OnRegisteredAsPlayer(RegistrationResults result, Versioning serverVersion, int playerId, bool isServerMaster)
 {
     if (result == RegistrationResults.RegistrationSuccessful)
     {
         if (Client.IsServerMaster)
         {
             Client.ChangeOptions(Options);
         }
         else
         {
             Options = Client.Options;
         }
         IsGameNotStarted = !Client.IsGameStarted;
     }
 }
 void StockOnParameterChange(Contract c, ContractParameter p)
 {
     // Workaround for stock bug #18267
     if (p.State == ParameterState.Complete && p.FundsCompletion == 0 && p.ScienceCompletion == 0 && p.ReputationCompletion == 0)
     {
         Versioning v = Versioning.Instance as Versioning;
         if (v.versionMajor == 1 && v.versionMinor == 4 && v.revision == 2)
         {
             MessageSystem.Message message = MessageSystem.Instance.FindMessages(m => m.message.Contains(p.MessageComplete)).FirstOrDefault();
             if (message != null)
             {
                 MessageSystem.Instance.DiscardMessage(message.button);
             }
         }
     }
 }
Пример #27
0
        private void Register(string playerName, string team)
        {
            Log.Default.WriteLine(LogLevels.Info, "Registering");
            State = States.Registering;

            PlayerName = playerName;
            Team       = team;
            Version    version       = Assembly.GetEntryAssembly().GetName().Version;
            Versioning clientVersion = new Versioning
            {
                Major = version.Major,
                Minor = version.Minor,
            };

            Proxy.RegisterPlayer(this, clientVersion, playerName, team);
        }
Пример #28
0
 private void OnRegisteredAsSpectator(RegistrationResults result, Versioning serverVersion, int spectatorId)
 {
     if (result == RegistrationResults.RegistrationSuccessful)
     {
         IsRegistered       = true;
         PlayFieldViewModel = PlayFieldSpectatorViewModel;
         OnPropertyChanged("PlayFieldViewModel");
         if (ClientOptionsViewModel.Instance.AutomaticallySwitchToPartyLineOnRegistered)
         {
             if (ActiveTabItemIndex == ConnectionViewModel.TabIndex)
             {
                 ActiveTabItemIndex = PartyLineViewModel.TabIndex;
             }
         }
     }
 }
        public void Outputter_Environment_WritesToEnvironment()
        {
            b.Info.Flow();


            MockVersionStorage mvs = new MockVersionStorage("0.0.0.1");
            var sut = new Versioning(mvs);
            var v   = sut.Version;

            var op = new MockVersioningOutputter(v);

            op.DoOutput(OutputPossibilities.File);

            Assert.True(op.FileWasWritten);
            Assert.False(op.EnvWasSet);
        }
Пример #30
0
        public void GetObjectData(SerializationInfo info, StreamingContext context)
        {
            info.AddValue("version", 2);

            Type myType = this.GetType();
            IList <PropertyInfo> props = new List <PropertyInfo>(myType.GetProperties().Where(p => p.GetCustomAttribute(typeof(Versioning)) != null));

            foreach (PropertyInfo prop in props)
            {
                object propValue = prop.GetValue(this, null);

                Versioning att = (Versioning)prop.GetCustomAttribute(typeof(Versioning));

                info.AddValue(att.Name, propValue);
            }
        }
Пример #31
0
        /// <summary>
        /// Creates a new instance of the IpcBinaryClientProtocolSetup class.
        /// </summary>
        /// <param name="versioning">Versioning behavior</param>
        public IpcBinaryClientProtocolSetup(Versioning versioning)
            : base((settings, clientSinkChain, serverSinkChain) => new IpcChannel(settings, clientSinkChain, serverSinkChain))
        {
            _channelName = "IpcBinaryClientProtocol_" + Guid.NewGuid().ToString();
            _versioning  = versioning;

            Hashtable formatterSettings = new Hashtable();

            formatterSettings.Add("includeVersions", _versioning == Versioning.Strict);
            formatterSettings.Add("strictBinding", _versioning == Versioning.Strict);

            ClientSinkChain.Add(new BinaryClientFormatterSinkProvider(formatterSettings, null));
            ServerSinkChain.Add(new BinaryServerFormatterSinkProvider(formatterSettings, null)
            {
                TypeFilterLevel = TypeFilterLevel.Full
            });
        }
Пример #32
0
        /// <summary>
        /// Creates a new instance of the TcpDuplexServerProtocolSetup class.
        /// </summary>
        /// <param name="versioning">Versioning behavior</param>
        public TcpDuplexServerProtocolSetup(Versioning versioning)
            : base((settings, clientSinkChain, serverSinkChain) => new TcpExChannel(settings, clientSinkChain, serverSinkChain))
        {
            _versioning = versioning;

            Hashtable formatterSettings = new Hashtable();

            formatterSettings.Add("includeVersions", _versioning == Versioning.Strict);
            formatterSettings.Add("strictBinding", _versioning == Versioning.Strict);

            ClientSinkChain.Add(new SafeBinaryClientFormatterSinkProvider(formatterSettings, null));
            ServerSinkChain.Add(new SafeBinaryServerFormatterSinkProvider(formatterSettings, null)
            {
                TypeFilterLevel = TypeFilterLevel.Full
            });
            ServerSinkChain.Add(new ClientAddressServerChannelSinkProvider());
        }
        private void PostHandleCrmAssemblyProjects(Project project, IVsPackageInstaller installer)
        {
            try
            {
                project.DTE.SuppressUI = true;

                //Pre-2015 use .NET 4.0
                if (Versioning.StringToVersion(_coreVersion).Major < 7)
                {
                    project.Properties.Item("TargetFrameworkMoniker").Value = ".NETFramework,Version=v4.0";
                }
                //Plug-in & workflows use .NET 4.5.2
                else if (_crmProjectType == ProjectType.Plugin || _crmProjectType == ProjectType.Workflow)
                {
                    project.Properties.Item("TargetFrameworkMoniker").Value = ".NETFramework,Version=v4.5.2";
                }
                //Console v9+ use .NET 4.6.2 //TODO: Getting "Project Unavailable" message when finished but project builds fine
                //else if (_crmProjectType == ProjectType.Console && Versioning.StringToVersion(_coreVersion).Major >= 9)
                //    project.Properties.Item("TargetFrameworkMoniker").Value = ".NETFramework,Version=v4.6.2";

                //Install all the NuGet packages
                project = (Project)((Array)_dte.ActiveSolutionProjects).GetValue(0);
                NuGetProcessor.InstallPackage(installer, project, Resource.SdkAssemblyCore, _coreVersion);
                if (_needsWorkflow)
                {
                    NuGetProcessor.InstallPackage(installer, project, Resource.SdkAssemblyWorkflow, _coreVersion);
                }
                if (_needsClient)
                {
                    NuGetProcessor.InstallPackage(installer, project, _clientPackage, _clientVersion);
                }

                ProjectWorker.ExcludeFolder(project, "bin");
                ProjectWorker.ExcludeFolder(project, "performance");

                if (_signAssembly)
                {
                    Signing.GenerateKey(project, _destDirectory);
                }
            }
            catch (Exception ex)
            {
                ExceptionHandler.LogException(Logger, Resource.ErrorMessage_ErrorProcessingTemplate, ex);
                MessageBox.Show(Resource.ErrorMessage_ErrorProcessingTemplate);
            }
        }
Пример #34
0
        /// <summary>
        /// Replaces the common tokens like "[year]" with their appropriate values as gathered from KSP
        /// </summary>
        /// <param name="sourceString">The source string to act on</param>
        /// <returns>The string post replacements</returns>
        public static string ReplaceStandardTokens(string sourceString)
        {
            string str = sourceString;

            str = ReplaceToken(str, "UT", Planetarium.fetch != null ? Math.Round(Planetarium.GetUniversalTime()).ToString() : "0");
            str = ReplaceToken(str, "save", HighLogic.SaveFolder != null && HighLogic.SaveFolder.Trim().Length > 0 ? HighLogic.SaveFolder : "NA");
            str = ReplaceToken(str, "version", Versioning.GetVersionString());
            str = ReplaceToken(str, "vessel", HighLogic.LoadedSceneIsFlight && FlightGlobals.ActiveVessel != null ? FlightGlobals.ActiveVessel.vesselName : "NA");
            str = ReplaceToken(str, "body", Planetarium.fetch != null ? Planetarium.fetch.CurrentMainBody.GetDisplayName() : "NA");
            str = ReplaceToken(str, "situation", HighLogic.LoadedSceneIsFlight && FlightGlobals.ActiveVessel != null ? FlightGlobals.ActiveVessel.situation.ToString() : "NA");
            str = ReplaceToken(str, "biome", HighLogic.LoadedSceneIsFlight && FlightGlobals.ActiveVessel != null ? ScienceUtil.GetExperimentBiome(FlightGlobals.ActiveVessel.mainBody, FlightGlobals.ActiveVessel.latitude, FlightGlobals.ActiveVessel.longitude) : "NA");


            double ut = 0;

            int[] times = { 0, 0, 0, 0, 0 };
            if (Planetarium.fetch != null)
            {
                ut    = Planetarium.GetUniversalTime();
                times = Utilities.ConvertUT(ut);
            }
            str = ReplaceToken(str, "year", times[0].ToString());
            str = ReplaceToken(str, "year0", times[0].ToString("D3"));
            str = ReplaceToken(str, "day", times[1].ToString());
            str = ReplaceToken(str, "day0", times[1].ToString("D3"));
            str = ReplaceToken(str, "hour", times[2].ToString());
            str = ReplaceToken(str, "hour0", times[2].ToString("D2"));
            str = ReplaceToken(str, "min", times[3].ToString());
            str = ReplaceToken(str, "min0", times[3].ToString("D2"));
            str = ReplaceToken(str, "sec", times[4].ToString());
            str = ReplaceToken(str, "sec0", times[4].ToString("D2"));
            str = ReplaceToken(str, "kspDate", KSPUtil.PrintDate(ut, false).Trim());

            string time = KSPUtil.PrintTimeCompact(0, false);

            if (HighLogic.LoadedSceneIsFlight && FlightGlobals.ActiveVessel != null)
            {
                time = KSPUtil.PrintTimeCompact((int)FlightGlobals.ActiveVessel.missionTime, false);
            }
            time = time.Replace(":", "-"); //Can't use colons in filenames on Windows, so we'll replace them with "-"

            str = ReplaceToken(str, "MET", time);

            return(str);
        }
Пример #35
0
 private void OnRegisteredAsSpectator(RegistrationResults result, Versioning serverVersion, int spectatorId)
 {
     if (result == RegistrationResults.RegistrationSuccessful)
     {
         string version = serverVersion == null ? "Unknown server version. Use at your own risk." : String.Format("Server version {0}.{1}", serverVersion.Major, serverVersion.Minor);
         SetConnectionResultMessage(ChatColor.Green, "Registered as spectator {0}. {1}", spectatorId + 1, version);
     }
     else
     {
         string version = serverVersion == null ? "Unknown server version" : String.Format("Server version {0}.{1}", serverVersion.Major, serverVersion.Minor);
         DescriptionAttribute attribute = EnumHelper.GetAttribute <DescriptionAttribute>(result);
         Client.UnregisterAndDisconnect();
         SetConnectionResultMessage(ChatColor.Red, "Registration failed: {0}. {1}", attribute == null ? result.ToString() : attribute.Description, version);
     }
     _isRegistered = Client.IsRegistered;
     OnPropertyChanged("ConnectDisconnectLabel");
     OnPropertyChanged("IsNotRegistered");
 }
Пример #36
0
        public static SortedList<string, string> ResolveScriptsFromPathAndVersion(string path, string pattern, bool recurse, string workingDirectory, Versioning.Version source, Versioning.Version destination, Versioning.IParseVersions versionParser = null)
        {
            SortedList<string, string> files = new SortedList<string, string>();
            if (versionParser == null) versionParser = new Versioning.VersionDateParser();
            string usedPath = path;
            if (!System.IO.Directory.Exists(usedPath)) usedPath = System.IO.Path.Combine(workingDirectory, path);
            if (!System.IO.Directory.Exists(usedPath)) throw new ArgumentOutOfRangeException("path");
            foreach (var d in System.IO.Directory.GetDirectories(usedPath))
            {
                System.IO.DirectoryInfo dir = new DirectoryInfo(d);
                Versioning.Version dirVersion = versionParser.Parse(dir.Name);
                if (dirVersion >= source && dirVersion <= destination)
                {
                    var scripts = ResolveScriptsFromPath(dir.FullName, pattern, recurse, workingDirectory);
                    foreach (string key in scripts.Keys)
                    {
                        files.Add(key, scripts[key]);
                    }

                }
            }

            return files;
        }
Пример #37
0
 /// <summary>
 /// Creates a new instance of the TcpDuplexServerProtocolSetup class.
 /// </summary>
 /// <param name="versioning">Versioning behavior</param>
 /// <param name="tcpPort">TCP port number</param>
 /// <param name="authProvider">Authentication provider</param>
 /// <param name="keepAlive">Enables or disables TCP KeepAlive for the new connection</param>
 /// <param name="keepAliveTime">Time for TCP KeepAlive in Milliseconds</param>
 /// <param name="KeepAliveInterval">Interval for TCP KeepAlive in Milliseconds</param>
 public TcpDuplexServerProtocolSetup(Versioning versioning, int tcpPort, IAuthenticationProvider authProvider, bool keepAlive, ulong keepAliveTime, ulong KeepAliveInterval)
     : this(versioning)
 {
     TcpPort = tcpPort;
     AuthenticationProvider = authProvider;
     TcpKeepAliveEnabled = keepAlive;
     TcpKeepAliveTime = keepAliveTime;
     TcpKeepAliveInterval = KeepAliveInterval;
 }
Пример #38
0
 /// <summary>
 /// Creates a new instance of the TcpDuplexServerProtocolSetup class.
 /// </summary>
 /// <param name="versioning">Versioning behavior</param>
 /// <param name="tcpPort">TCP port number</param>
 /// <param name="authProvider">Authentication provider</param>
 /// <param name="encryption">Specifies if the communication sould be encrypted</param>
 /// <param name="algorithm">Encryption algorithm (e.G. "3DES")</param>
 /// <param name="oaep">Specifies if OAEP padding should be activated</param>
 public TcpDuplexServerProtocolSetup(Versioning versioning, int tcpPort, IAuthenticationProvider authProvider, bool encryption, string algorithm, bool oaep)
     : this(versioning)
 {
     TcpPort = tcpPort;
     AuthenticationProvider = authProvider;
     Encryption = encryption;
     Algorithm = algorithm;
     Oaep = oaep;
 }
Пример #39
0
 /// <summary>
 /// Creates a new instance of the HttpCustomClientProtocolSetup class.
 /// </summary>
 /// <param name="versioning">Versioning behavior</param>
 /// <param name="encryption">Specifies if the communication sould be encrypted</param>
 /// <param name="algorithm">Encryption algorithm (e.G. "3DES")</param>
 /// <param name="maxAttempts">Maximum number of connection attempts</param>
 /// <param name="webProxy">Defines HTTP proxy settings</param>
 public HttpCustomClientProtocolSetup(Versioning versioning, bool encryption, string algorithm, int maxAttempts, IWebProxy webProxy)
     : this(versioning, webProxy)
 {
     Encryption = encryption;
     Algorithm = algorithm;
     MaxAttempts = maxAttempts;
 }
Пример #40
0
 /// <summary>
 /// Creates a new instance of the HttpCustomClientProtocolSetup class.
 /// </summary>
 /// <param name="versioning">Versioning behavior</param>
 /// <param name="encryption">Specifies if the communication sould be encrypted</param>
 /// <param name="webProxy">Defines HTTP proxy settings</param>
 public HttpCustomClientProtocolSetup(Versioning versioning, bool encryption, IWebProxy webProxy)
     : this(versioning, webProxy)
 {
     Encryption = encryption;
 }
Пример #41
0
 /// <summary>
 /// Creates a new instance of the HttpCustomServerProtocolSetup class.
 /// </summary>
 /// <param name="versioning">Versioning behavior</param>
 /// <param name="httpPort">HTTP port number</param>
 /// <param name="authProvider">Authentication provider</param>
 /// <param name="encryption">Specifies if the communication sould be encrypted</param>
 /// <param name="algorithm">Encryption algorithm (e.G. "3DES")</param>
 /// <param name="oaep">Specifies if OAEP padding should be activated</param>
 public HttpCustomServerProtocolSetup(Versioning versioning, int httpPort, IAuthenticationProvider authProvider, bool encryption, string algorithm, bool oaep)
     : this(versioning)
 {
     HttpPort = httpPort;
     AuthenticationProvider = authProvider;
     Encryption = encryption;
     Algorithm = algorithm;
     Oaep = oaep;
 }
Пример #42
0
 /// <summary>
 /// Creates a new instance of the HttpCustomClientProtocolSetup class.
 /// </summary>
 /// <param name="versioning">Versioning behavior</param>
 /// <param name="encryption">Specifies if the communication sould be encrypted</param>
 /// <param name="algorithm">Encryption algorithm (e.G. "3DES")</param>
 /// <param name="oaep">Specifies if OAEP padding should be activated</param>
 /// <param name="webProxy">Defines HTTP proxy settings</param>
 public HttpCustomClientProtocolSetup(Versioning versioning, bool encryption, string algorithm, bool oaep, IWebProxy webProxy)
     : this(versioning, webProxy)
 {
     Encryption = encryption;
     Algorithm = algorithm;
     Oaep = oaep;
 }
Пример #43
0
 /// <summary>
 /// Creates a new instance of the TcpDuplexClientProtocolSetup class.
 /// </summary>
 /// <param name="versioning">Versioning behavior</param>
 /// <param name="encryption">Specifies if the communication sould be encrypted</param>
 /// <param name="algorithm">Symmetric encryption algorithm (e.G. "3DES")</param>
 /// <param name="oaep">Specifies if OAEP padding should be activated</param>
 public TcpDuplexClientProtocolSetup(Versioning versioning, bool encryption, string algorithm, bool oaep)
     : this(versioning)
 {
     Encryption = encryption;
     Algorithm = algorithm;
     Oaep = oaep;
 }
Пример #44
0
 /// <summary>
 /// Creates a new instance of the TcpDuplexServerProtocolSetup class.
 /// </summary>
 /// <param name="versioning">Versioning behavior</param>
 /// <param name="tcpPort">TCP port number</param>
 /// <param name="authProvider">Authentication provider</param>
 public TcpDuplexServerProtocolSetup(Versioning versioning, int tcpPort, IAuthenticationProvider authProvider)
     : this(versioning)
 {
     TcpPort = tcpPort;
     AuthenticationProvider = authProvider;
 }
        public override async Task<Newtonsoft.Json.Linq.JObject> GetPackageMetadata(string id, Versioning.NuGetVersion version)
        {
            foreach (var source in _sources)
            {
                var result = await source.GetPackageMetadata(id, version);
                if (result != null)
                {
                    return result;
                }
            }

            return null;
        }
Пример #46
0
        public override Task<JObject> GetPackageMetadata(string id, Versioning.NuGetVersion version)
        {
            return Task.Factory.StartNew(() =>
            {
                NuGetTraceSources.V2SourceRepository.Verbose("getpackage", "Getting metadata for {0} {1}", id, version);
                var semver = CoreConverters.SafeToSemanticVersion(version);
                var package = _repository.FindPackage(id, semver);

                // Sometimes, V2 APIs seem to fail to return a value for Packages(Id=,Version=) requests...
                if (package == null)
                {
                    var packages = _repository.FindPackagesById(id);
                    package = packages.FirstOrDefault(p => Equals(p.Version, semver));
                }

                // If still null, fail
                if (package == null)
                {
                    return null;
                }

                string repoRoot = null;
                IPackagePathResolver resolver = null;
                if (_lprepo != null)
                {
                    repoRoot = _lprepo.Source;
                    resolver = _lprepo.PathResolver;
                }

                return PackageJsonLd.CreatePackage(package, repoRoot, resolver);
            });
        }
 public override async Task<Newtonsoft.Json.Linq.JObject> GetPackageMetadata(string id, Versioning.NuGetVersion version)
 {
     await DetectVersionWhenNeccessary();
     return await _repo.GetPackageMetadata(id, version);
 }
Пример #48
0
 /// <summary>
 /// Creates a new instance of the HttpCustomServerProtocolSetup class.
 /// </summary>
 /// <param name="versioning">Versioning behavior</param>
 /// <param name="httpPort">HTTP port number</param>
 /// <param name="authProvider">Authentication provider</param>
 public HttpCustomServerProtocolSetup(Versioning versioning, int httpPort, IAuthenticationProvider authProvider)
     : this(versioning)
 {
     HttpPort = httpPort;
     AuthenticationProvider = authProvider;
 }
Пример #49
0
 /// <summary>
 /// Creates a new instance of the TcpBinaryServerProtocolSetup class.
 /// </summary>
 /// <param name="versioning">Versioning behavior</param>
 /// <param name="tcpPort">TCP port number</param>
 public TcpBinaryServerProtocolSetup(Versioning versioning, int tcpPort)
     : this(versioning)
 {
     TcpPort = tcpPort;
 }
Пример #50
0
 /// <summary>
 /// Creates a new instance of the TcpDuplexServerProtocolSetup class.
 /// </summary>
 /// <param name="versioning">Versioning behavior</param>
 /// <param name="tcpPort">TCP port number</param>
 /// <param name="authProvider">Authentication provider</param>
 /// <param name="encryption">Specifies if the communication sould be encrypted</param>
 /// <param name="algorithm">Encryption algorithm (e.G. "3DES")</param>
 /// <param name="oaep">Specifies if OAEP padding should be activated</param>
 /// <param name="keepAlive">Enables or disables TCP KeepAlive for the new connection</param>
 /// <param name="keepAliveTime">Time for TCP KeepAlive in Milliseconds</param>
 /// <param name="KeepAliveInterval">Interval for TCP KeepAlive in Milliseconds</param>
 public TcpDuplexServerProtocolSetup(Versioning versioning, int tcpPort, IAuthenticationProvider authProvider, bool encryption, string algorithm, bool oaep, bool keepAlive, ulong keepAliveTime, ulong KeepAliveInterval)
     : this(versioning)
 {
     TcpPort = tcpPort;
     AuthenticationProvider = authProvider;
     Encryption = encryption;
     Algorithm = algorithm;
     Oaep = oaep;
     TcpKeepAliveEnabled = keepAlive;
     TcpKeepAliveTime = keepAliveTime;
     TcpKeepAliveInterval = KeepAliveInterval;
 }
Пример #51
0
 /// <summary>
 /// Creates a new instance of the TcpCustomClientProtocolSetup class.
 /// </summary>
 /// <param name="versioning">Versioning behavior</param>
 /// <param name="encryption">Specifies if the communication sould be encrypted</param>
 public TcpCustomClientProtocolSetup(Versioning versioning, bool encryption)
     : this(versioning)
 {
     Encryption = encryption;
 }
Пример #52
0
 /// <summary>
 /// Creates a new instance of the TcpDuplexClientProtocolSetup class.
 /// </summary>
 /// <param name="versioning">Versioning behavior</param>
 /// <param name="encryption">Specifies if the communication sould be encrypted</param>
 /// <param name="algorithm">Symmetric encryption algorithm (e.G. "3DES")</param>
 /// <param name="maxAttempts">Maximum number of connection attempts</param>
 public TcpDuplexClientProtocolSetup(Versioning versioning, bool encryption, string algorithm, int maxAttempts)
     : this(versioning)
 {
     Encryption = encryption;
     Algorithm = algorithm;
     MaxAttempts = maxAttempts;
 }
Пример #53
0
 /// <summary>
 /// Creates a new instance of the TcpCustomClientProtocolSetup class.
 /// </summary>
 /// <param name="versioning">Versioning behavior</param>
 /// <param name="encryption">Specifies if the communication sould be encrypted</param>
 /// <param name="algorithm">Encryption algorithm (e.G. "3DES")</param>
 public TcpCustomClientProtocolSetup(Versioning versioning, bool encryption, string algorithm)
     : this(versioning)
 {
     Encryption = encryption;
     Algorithm = algorithm;
 }
Пример #54
0
 /// <summary>
 /// Creates a new instance of the TcpDuplexClientProtocolSetup class.
 /// </summary>
 /// <param name="versioning">Versioning behavior</param>
 /// <param name="encryption">Specifies if the communication sould be encrypted</param>
 /// <param name="keepAlive">Enables or disables TCP KeepAlive for the new connection</param>
 /// <param name="keepAliveTime">Time for TCP KeepAlive in Milliseconds</param>
 /// <param name="KeepAliveInterval">Interval for TCP KeepAlive in Milliseconds</param>
 public TcpDuplexClientProtocolSetup(Versioning versioning, bool encryption, bool keepAlive, ulong keepAliveTime, ulong KeepAliveInterval)
     : this(versioning)
 {
     Encryption = encryption;
     TcpKeepAliveEnabled = keepAlive;
     TcpKeepAliveTime = keepAliveTime;
     TcpKeepAliveInterval = KeepAliveInterval;
 }
Пример #55
0
 public bool ParseAndValidate(string version, Versioning.Version testVersion, Versioning.IParseVersions parser = null)
 {
     if (parser == null) parser = new Versioning.JustVersionParser();
     Versioning.Version v = parser.Parse(version);
     return (v.Major == testVersion.Major && v.Minor == testVersion.Minor && v.Build == testVersion.Build &&
             v.Description == testVersion.Description);
 }
Пример #56
0
 /// <summary>
 /// Creates a new instance of the TcpCustomClientProtocolSetup class.
 /// </summary>
 /// <param name="versioning">Versioning behavior</param>
 /// <param name="encryption">Specifies if the communication sould be encrypted</param>
 /// <param name="algorithm">Encryption algorithm (e.G. "3DES")</param>
 /// <param name="maxAttempts">Maximum number of connection attempts</param>
 /// <param name="oaep">Specifies if OAEP padding should be used</param>
 public TcpCustomClientProtocolSetup(Versioning versioning, bool encryption, string algorithm, int maxAttempts, bool oaep)
     : this(versioning)
 {
     Encryption = encryption;
     Algorithm = algorithm;
     MaxAttempts = maxAttempts;
     Oaep = oaep;
 }
Пример #57
0
 /// <summary>
 /// Creates a new instance of the TcpDuplexClientProtocolSetup class.
 /// </summary>
 /// <param name="versioning">Versioning behavior</param>
 /// <param name="encryption">Specifies if the communication sould be encrypted</param>
 /// <param name="algorithm">Symmetric encryption algorithm (e.G. "3DES")</param>
 /// <param name="maxAttempts">Maximum number of connection attempts</param>
 /// <param name="oaep">Specifies if OAEP padding should be activated</param>
 /// <param name="keepAlive">Enables or disables TCP KeepAlive for the new connection</param>
 /// <param name="keepAliveTime">Time for TCP KeepAlive in Milliseconds</param>
 /// <param name="KeepAliveInterval">Interval for TCP KeepAlive in Milliseconds</param>
 public TcpDuplexClientProtocolSetup(Versioning versioning, bool encryption, string algorithm, int maxAttempts, bool oaep, bool keepAlive, ulong keepAliveTime, ulong KeepAliveInterval)
     : this(versioning)
 {
     Encryption = encryption;
     Algorithm = algorithm;
     MaxAttempts = maxAttempts;
     Oaep = oaep;
     TcpKeepAliveEnabled = keepAlive;
     TcpKeepAliveTime = keepAliveTime;
     TcpKeepAliveInterval = KeepAliveInterval;
 }
Пример #58
0
 /// <summary>
 /// Creates a new instance of the HttpCustomClientProtocolSetup class.
 /// </summary>
 /// <param name="versioning">Versioning behavior</param>
 public HttpCustomClientProtocolSetup(Versioning versioning)
     : this(versioning, WebRequest.DefaultWebProxy)
 {
 }
Пример #59
0
 /// <summary>
 /// Creates a new instance of the TcpCustomServerProtocolSetup class.
 /// </summary>
 /// <param name="versioning">Versioning behavior</param>
 /// <param name="tcpPort">TCP port number</param>
 /// <param name="authProvider">Authentication provider</param>
 /// <param name="encryption">Specifies if the communication sould be encrypted</param>
 /// <param name="algorithm">Encryption algorithm (e.G. "3DES")</param>
 public TcpCustomServerProtocolSetup(Versioning versioning, int tcpPort, IAuthenticationProvider authProvider, bool encryption, string algorithm)
     : this(versioning)
 {
     TcpPort = tcpPort;
     AuthenticationProvider = authProvider;
     Encryption = encryption;
     Algorithm = algorithm;
 }