public LevelLoaderService(UnitRegistry unitRegistry,
                           IFactory <UnitData, AllianceType, WorldPosition, SpawnUnitCommand> spawnUnitCommandFactory, CommandProcessor commandProcessor)
 {
     _spawnUnitCommandFactory = spawnUnitCommandFactory;
     _commandProcessor        = commandProcessor;
     _unitRegistry            = unitRegistry;
 }
Esempio n. 2
0
        public bool ReloadUnit(string name)
        {
            var transaction = UnitRegistry.GetUnit(name).GetReloadTransaction();
            var result      = transaction.Execute();

            return(result.Type == Tasks.ResultType.Success);
        }
Esempio n. 3
0
        public UnitExpressionParserTests()
        {
            var unitRegistry = new UnitRegistry();

            this.lexicalAnalyzer = A.Fake <ILexicalAnalyzer>();
            this.testee          = new UnitExpressionParser(unitRegistry, this.lexicalAnalyzer);
        }
        public UnitRepository(UnitRegistry unitRegistry)
        {
            _unitRegistry = unitRegistry;

            ParseUnits();
            BridgeData.unitRepo = this;
        }
Esempio n. 5
0
 public bool LoadUnitFromFile(string path)
 {
     try
     {
         UnitRegistry.AddUnitByPath(path);
         return(true);
     }
     catch { return(false); }
 }
        public static void ClassInitialize(TestContext value)
        {
            PlatformUtilities.RegisterImplementations();
            PlatformUtilities.GetImplementation <IPlatformInitialization>().Initialize();
            UnitRegistry.InitializeTypes();
            UnitRegistry.ScanDefaultDirectories();

            File.WriteAllText(path, contents);
        }
        public void AddUnitByPath_UnitNotFound_True()
        {
            // Arrange

            // Act
            UnitRegistry.AddUnitByPath("");

            // Assert
            Assert.IsTrue(UnitRegistry.Units.Count == 0);
        }
 public AbilityMakerAbility(UnitModel unit, AbilityData data, WorldModel world, TickService tickservice,
                            CommandProcessor command, UnitRegistry unitRegistry, AbilityRepository abilityRepository)
 {
     _unit              = unit;
     _world             = world;
     _command           = command;
     _data              = new BuffAbilityParams(data);
     _tickService       = tickservice;
     _unitRegistry      = unitRegistry;
     _abilityRepository = abilityRepository;
 }
Esempio n. 9
0
    public BaseUnit CreateUnit <UnitClass> (Vector2Int coordinates) where UnitClass : BaseUnit
    {
        UnitClass unit = ScriptableObject.CreateInstance <UnitClass>();

        unit.ID      = UnitRegistry.setID();
        unit.xPos    = coordinates.x;
        unit.yPos    = coordinates.y;
        unit.ownerID = GameMaster.Instance.getActivePlayer();

        return(unit);
    }
        public void AddUnit_UnitIsNull_True()
        {
            // Arrange
            Unit unit = null;

            // Act
            UnitRegistry.AddUnit(unit);

            // Assert
            Assert.IsTrue(UnitRegistry.Units.Count == 0);
        }
        public void AddUnit_UnitIsAdded_True()
        {
            // Arrange
            Unit unit = new ServiceUnit(path);

            // Act
            UnitRegistry.AddUnit(unit);

            // Assert
            Assert.IsTrue(UnitRegistry.Units.Count == 1);
        }
        public void ScanDefaultDirectories_UnitsFound_True()
        {
            // Arrange
            Environment.SetEnvironmentVariable("SHARPINIT_UNIT_PATH", ".");
            var check = Environment.GetEnvironmentVariable("SHARPINIT_UNIT_PATH");
            // Act
            var result = UnitRegistry.ScanDefaultDirectories();

            // Assert
            Assert.IsTrue(UnitRegistry.Units.Count > 0);
        }
        public void AddUnit_UnitHasAlreadyBeenAdded_ThrowsException()
        {
            // Arrange
            Unit unit = new ServiceUnit(path);

            // Act
            UnitRegistry.AddUnit(unit);
            UnitRegistry.AddUnit(unit);

            // Assert
            // Exception Thrown
        }
Esempio n. 14
0
        public void AddUnitByPath_UnitFound_True()
        {
            // Arrange
            UnitRegistry.UnitFiles.Clear();
            UnitRegistry.Units.Clear();

            // Act
            UnitRegistry.IndexUnitByPath(TestUnitPath);

            // Assert
            Assert.IsNotNull(UnitRegistry.GetUnit(TestUnitFilename));
        }
Esempio n. 15
0
        public void AddUnitByPath_UnitNotFound_True()
        {
            // Arrange
            UnitRegistry.UnitFiles.Clear();
            UnitRegistry.Units.Clear();

            // Act
            UnitRegistry.IndexUnitByPath($"{DirectoryName}/nonexistent-unit.service");

            // Assert
            Assert.IsNull(UnitRegistry.GetUnit(TestUnitFilename));
        }
Esempio n. 16
0
        public void ScanDefaultDirectories_UnitsFound_True()
        {
            // Arrange
            Environment.SetEnvironmentVariable("SHARPINIT_UNIT_PATH", DirectoryName);
            UnitRegistry.DefaultScanDirectories.Clear();

            // Act
            UnitRegistry.ScanDefaultDirectories();

            // Assert
            Assert.IsTrue(UnitRegistry.UnitFiles.ContainsKey(TestUnitFilename));
        }
Esempio n. 17
0
        static void Main(string[] args)
        {
            Log.Info("SharpInit starting");

            PlatformUtilities.RegisterImplementations();
            PlatformUtilities.GetImplementation <IPlatformInitialization>().Initialize();

            Log.Info("Platform initialization complete");

            UnitRegistry.InitializeTypes();
            UnitRegistry.ScanDefaultDirectories();

            Log.Info($"Loaded {UnitRegistry.Units.Count} units");

            UnitRegistry.UnitStateChange += StateChangeHandler;

            Log.Info("Registering IPC context...");

            var context = new ServerIpcContext();

            IpcFunctionRegistry.AddFunction(DynamicIpcFunction.FromContext(context));

            Log.Info("Starting IPC listener...");

            var ipc_listener = new IpcListener();

            ipc_listener.StartListening();

            Log.Info($"Listening on {ipc_listener.SocketEndPoint}");

            if (UnitRegistry.GetUnit("default.target") != null)
            {
                Log.Info("Activating default.target...");
                var result = UnitRegistry.CreateActivationTransaction("default.target").Execute();

                if (result.Type == Tasks.ResultType.Success)
                {
                    Log.Info("Successfully activated default.target.");
                }
                else
                {
                    Log.Info($"Error while activating default.target: {result.Type}, {result.Message}");
                }
            }

            Console.CancelKeyPress += (s, e) =>
            {
                ipc_listener.StopListening();
            };

            Thread.Sleep(-1);
        }
 public SpawnUnitsAbility(UnitModel unit, AbilityData data, WorldModel world, TickService tickservice,
                          CommandProcessor command, UnitRegistry unitRegistry,
                          IFactory <IBuff, BuffData, BuffTargetCommand> buffFactory,
                          IFactory <StatChangeData, HPChangeCommand> HPChangeFactory,
                          IFactory <UnitData, AllianceType, WorldPosition, SpawnUnitCommand> spawnUnitCommandFactory)
 {
     _unit                    = unit;
     _world                   = world;
     _command                 = command;
     _data                    = new BuffAbilityParams(data);
     _tickService             = tickservice;
     _unitRegistry            = unitRegistry;
     _spawnUnitCommandFactory = spawnUnitCommandFactory;
 }
Esempio n. 19
0
        public UnitInfo GetUnitInfo(string unit_name)
        {
            var unit = UnitRegistry.GetUnit(unit_name);
            var info = new UnitInfo();

            info.Name                = unit.UnitName;
            info.Path                = unit.File.UnitPath;
            info.Description         = unit.File.Description;
            info.State               = Enum.Parse <Ipc.UnitState>(unit.CurrentState.ToString());
            info.LastStateChangeTime = unit.LastStateChangeTime;
            info.ActivationTime      = unit.ActivationTime;
            info.LoadTime            = unit.LoadTime;

            return(info);
        }
Esempio n. 20
0
        public void PercentSpecifier_Checks()
        {
            // Arrange
            Environment.SetEnvironmentVariable("SHARPINIT_UNIT_PATH", DirectoryName);
            UnitRegistry.DefaultScanDirectories.Clear();

            // Act
            UnitRegistry.ScanDefaultDirectories();
            var unit_unspecified = UnitRegistry.GetUnit <ServiceUnit>(TestUnitFilename);
            var unit_specified   = UnitRegistry.GetUnit <ServiceUnit>(TestUnitInstanceName);

            // Assert
            Assert.IsTrue(unit_unspecified.Descriptor.WorkingDirectory == "/" + StringEscaper.Unescape(unit_unspecified.Descriptor.DefaultInstance));
            Assert.IsTrue(unit_specified.Descriptor.WorkingDirectory == "/" + StringEscaper.Unescape(UnitRegistry.GetUnitParameter(TestUnitInstanceName)));
        }
Esempio n. 21
0
        public static void ClassInitialize(TestContext value)
        {
            PlatformUtilities.RegisterImplementations();
            PlatformUtilities.GetImplementation <IPlatformInitialization>().Initialize();
            UnitRegistry.InitializeTypes();

            Random rnd           = new Random();
            var    random_buffer = new byte[8];

            rnd.NextBytes(random_buffer);
            DirectoryName = BitConverter.ToString(random_buffer).Replace("-", "").ToLower();
            Directory.CreateDirectory(DirectoryName);

            File.WriteAllText(TestUnitPath, TestUnitContents);
        }
Esempio n. 22
0
 /// <summary>
 /// Initializes a new instance of the <see cref="UnitSystemDependencies"/> class.
 /// </summary>
 /// <param name="unitRegistry">The unit registry.</param>
 /// <param name="lexicalAnalyzer">The lexical analyzer.</param>
 /// <param name="expressionParser">The expression parser.</param>
 /// <param name="quantityParser">The quantity parser.</param>
 /// <param name="unitFactory">The unit factory.</param>
 /// <param name="quantityOperations">The quantity operations.</param>
 public UnitSystemDependencies(
     UnitRegistry unitRegistry,
     ILexicalAnalyzer lexicalAnalyzer,
     IExpressionParser expressionParser,
     IQuantityParser quantityParser,
     IUnitFactory unitFactory,
     IQuantityOperations quantityOperations)
 {
     this.UnitRegistry       = unitRegistry;
     this.LexicalAnalyzer    = lexicalAnalyzer;
     this.ExpressionParser   = expressionParser;
     this.QuantityParser     = quantityParser;
     this.UnitFactory        = unitFactory;
     this.QuantityOperations = quantityOperations;
 }
Esempio n. 23
0
        public void GetUnitName_Checks()
        {
            var dictionary = new Dictionary <string, string>()
            {
                { "/home/user/.config/sharpinit/units/[email protected]", "[email protected]" },
                { "/etc/sharpinit/units/[email protected]", "[email protected]" },
                { "C:\\Users\\User\\.config\\sharpinit\\units\\notepad.service", "notepad.service" },
                { "relative/path/to/[email protected]", "[email protected]" },
                { "backslash\\relative\\path\\test.target", "test.target" }
            };

            foreach (var pair in dictionary)
            {
                Assert.AreEqual(UnitRegistry.GetUnitName(pair.Key), pair.Value);
            }
        }
Esempio n. 24
0
        public UnitInfo GetUnitInfo(string unit_name)
        {
            var unit = UnitRegistry.GetUnit(unit_name);
            var info = new UnitInfo();

            var unit_files = unit.Descriptor.Files.OfType <OnDiskUnitFile>();

            info.Name = unit.UnitName;
            info.Path = unit_files.Any() ?
                        string.Join(", ", unit_files.Select(file => file.Path)) :
                        "(not available)";
            info.Description         = unit.Descriptor.Description;
            info.State               = Enum.Parse <Ipc.UnitState>(unit.CurrentState.ToString());
            info.LastStateChangeTime = unit.LastStateChangeTime;
            info.ActivationTime      = unit.ActivationTime;
            info.LoadTime            = unit.Descriptor.Created;

            return(info);
        }
Esempio n. 25
0
        public override TaskResult Execute()
        {
            var failure_type = StopExecution ? ResultType.StopExecution : ResultType.Failure;
            var unit         = UnitRegistry.GetUnit(TargetUnit);

            if (unit == null)
            {
                return(new TaskResult(this, failure_type, $"Unit {TargetUnit} is not loaded."));
            }

            var state = unit.CurrentState;

            if (ComparisonState.HasFlag(state) || ComparisonState == UnitState.Any)
            {
                return(new TaskResult(this, ResultType.Success));
            }

            return(new TaskResult(this, failure_type, $"Expected {TargetUnit} to be Active, it was instead {state}"));
        }
Esempio n. 26
0
        public bool DeactivateUnit(string name)
        {
            var transaction = UnitRegistry.CreateDeactivationTransaction(name);
            var result      = transaction.Execute();

            if (result.Type != ResultType.Success)
            {
                Log.Info($"Deactivation transaction failed. Result type: {result.Type}, message: {result.Message}");
                Log.Info("Transaction failed at highlighted task: ");

                var tree = transaction.GenerateTree(0, result.Task);

                foreach (var line in tree.Split('\n'))
                {
                    Log.Info(line);
                }
            }

            return(result.Type == ResultType.Success);
        }
Esempio n. 27
0
        /// <summary>
        /// Initializes the unit system.
        /// </summary>
        /// <param name="unitSystemDependencyFactory">The unit system dependency factory.</param>
        /// <param name="registerUnitAction">The register unit action.</param>
        /// <returns>A <see cref="UnitSystemDependencies"/>.</returns>
        public UnitSystemDependencies InitializeUnitSystem(
            IUnitSystemDependencyFactory unitSystemDependencyFactory,
            Action <IUnitRegistrar> registerUnitAction)
        {
            this.LockedAction(
                () =>
            {
                if (!this.isInitialized)
                {
                    unitSystemDependencyFactory = unitSystemDependencyFactory
                                                  ?? new UnitSystemDependencyFactory(
                        new ExpressionToFlatRepresentationConverter());
                    this.unitRegistry = unitSystemDependencyFactory.CreateUnitRegistry();
                    registerUnitAction?.Invoke(this.unitRegistry);
                    this.expressionParser = unitSystemDependencyFactory.CreateParser(this.unitRegistry);
                    this.lexicalAnalyzer  =
                        unitSystemDependencyFactory.CreateLexicalAnalyzer(TokenMatching.CompositeUnit);
                    this.unitFactory    = unitSystemDependencyFactory.CreateUnitFactory(this.unitRegistry);
                    this.quantityParser = unitSystemDependencyFactory.CreateParser(
                        this.expressionParser,
                        this.unitFactory);
                    this.quantityOperations =
                        unitSystemDependencyFactory.CreateQuantityOperations(this.unitFactory);
                    this.Dependencies = new UnitSystemDependencies(
                        this.unitRegistry,
                        this.lexicalAnalyzer,
                        this.expressionParser,
                        this.quantityParser,
                        this.unitFactory,
                        this.quantityOperations);
                    this.isInitialized = true;
                }
            });

            return(this.Dependencies);
        }
Esempio n. 28
0
 public int RescanUnits()
 {
     return(UnitRegistry.ScanDefaultDirectories());
 }
 public UnitExpressionParserTests()
 {
     var unitRegistry = new UnitRegistry();
     this.lexicalAnalyzer = A.Fake<ILexicalAnalyzer>();
     this.testee = new UnitExpressionParser(unitRegistry, this.lexicalAnalyzer);
 }
Esempio n. 30
0
        public Dictionary <string, List <string> > GetDeactivationPlan(string unit)
        {
            var transaction = UnitRegistry.CreateDeactivationTransaction(unit);

            return(transaction.Reasoning.ToDictionary(t => t.Key.UnitName, t => t.Value));
        }
Esempio n. 31
0
 public bool ReloadUnitFile(string unit)
 {
     UnitRegistry.GetUnit(unit).ReloadUnitFile();
     return(true);
 }