├── docs
    └── appliance
    │   ├── vols
    │       ├── entry.d
    │       │   ├── 99-entry-complete.sh
    │       │   ├── entrypoint
    │       │   └── 01-trust-certs.sh
    │       ├── identity-conf
    │       │   ├── identity-ui-settings.json
    │       │   ├── notice.html
    │       │   └── identity-seed.json
    │       ├── nginx
    │       │   ├── conf.d
    │       │   │   ├── connect.conf
    │       │   │   ├── default.conf
    │       │   │   ├── topomojo.conf
    │       │   │   └── identity.conf
    │       │   ├── html
    │       │   │   └── index.html
    │       │   └── nginx.conf
    │       └── topomojo-conf
    │       │   └── topomojo-ui-settings.json
    │   ├── cfssl
    │       ├── scripts
    │       │   ├── meta-ca.json
    │       │   ├── meta-int.json
    │       │   ├── meta-host.json
    │       │   ├── generate-certificate.sh
    │       │   └── config.json
    │       ├── setup.sh
    │       └── Readme.md
    │   ├── scripts
    │       ├── start.sh
    │       ├── enable-apphost.sh
    │       ├── set-proxy.sh
    │       ├── ova-shutdown.sh
    │       └── install-docker.sh
    │   └── docker-compose.yml
├── src
    ├── TopoMojo.Web
    │   ├── seed-data.json.example
    │   ├── Exceptions
    │   │   └── Exceptions.cs
    │   ├── Models
    │   │   ├── DocumentModels.cs
    │   │   └── DbSeedModel.cs
    │   ├── Options
    │   │   ├── DatabaseOptions.cs
    │   │   ├── CacheOptions.cs
    │   │   ├── FileUploadOptions.cs
    │   │   ├── AuthorizationOptions.cs
    │   │   ├── BrandingOptions.cs
    │   │   └── HeaderOptions.cs
    │   ├── web.config
    │   ├── Extensions
    │   │   ├── ClaimsPrincipalExtensions.cs
    │   │   ├── FileUploadStartupExtensions.cs
    │   │   ├── IdentityExtensions.cs
    │   │   ├── IdentityResolverStartupExtensions.cs
    │   │   ├── TopoMojoStartupExtensions.cs
    │   │   ├── CorsExtensions.cs
    │   │   ├── CachingExtensions.cs
    │   │   ├── DatabaseExtensions.cs
    │   │   └── ForwardingStartupExtensions.cs
    │   ├── migration-undo.ps1
    │   ├── migration-undo.sh
    │   ├── Infrastructure
    │   │   ├── HubCache.cs
    │   │   ├── ApiKeyAuthenticationExtensions.cs
    │   │   ├── TicketAuthenticationExtensions.cs
    │   │   ├── ServiceHostWrapper.cs
    │   │   ├── DisableFormValueModelBindingFilter.cs
    │   │   ├── RequestFormLimitsFilter.cs
    │   │   ├── TextMediaTypeFormatter.cs
    │   │   ├── ScheduledTasksService.cs
    │   │   ├── HeaderInspectionMiddleware.cs
    │   │   ├── JsonExceptionMiddleware.cs
    │   │   ├── CrossSiteRequestMiddleware.cs
    │   │   ├── FileUploadMonitor.cs
    │   │   └── BearerCookieMiddleware.cs
    │   ├── migration-add.sh
    │   ├── AppConstants.cs
    │   ├── migration-add.ps1
    │   ├── Data
    │   │   └── Migrations
    │   │   │   ├── PostgreSQL
    │   │   │       └── TopoMojoDb
    │   │   │       │   ├── 20210206154002_challenge.cs
    │   │   │       │   ├── 20200603185146_Audience.cs
    │   │   │       │   └── 20210218013150_ExpandTemplateLimits.cs
    │   │   │   └── SqlServer
    │   │   │       └── TopoMojoDb
    │   │   │           ├── 20210206153956_challenge.cs
    │   │   │           ├── 20210218013145_ExpandTemplateLimits.cs
    │   │   │           └── 20200603185140_Audience.cs
    │   ├── TopoMojo.Web.csproj
    │   ├── Controllers
    │   │   ├── _Controller.cs
    │   │   └── ChatController.cs
    │   └── Program.cs
    ├── TopoMojo.Client
    │   ├── Options.cs
    │   ├── TopoMojo.Client.csproj
    │   ├── StartupExtensions.cs
    │   └── TopoMojoStub.cs
    ├── TopoMojo.Abstractions
    │   ├── Models
    │   │   ├── Client.cs
    │   │   ├── JanitorReport.cs
    │   │   ├── Document.cs
    │   │   ├── ConsoleSummary.cs
    │   │   ├── Search.cs
    │   │   ├── Message.cs
    │   │   ├── User.cs
    │   │   ├── GamespaceSpec.cs
    │   │   ├── GamespaceModels.cs
    │   │   ├── VmTemplate.cs
    │   │   ├── Registration.cs
    │   │   ├── HypervisorServiceConfiguration.cs
    │   │   ├── Vm.cs
    │   │   ├── WorkspaceModels.cs
    │   │   └── TemplateModels.cs
    │   ├── Interfaces
    │   │   ├── IIdentityResolver.cs
    │   │   ├── ITopoMojoClient.cs
    │   │   └── IHypervisorService.cs
    │   └── TopoMojo.Abstractions.csproj
    ├── TopoMojo.Core
    │   ├── Data
    │   │   ├── Abstractions
    │   │   │   ├── IStoreUserContext.cs
    │   │   │   ├── IEntity.cs
    │   │   │   ├── IUserStore.cs
    │   │   │   ├── ITemplateStore.cs
    │   │   │   ├── IDataStore[TEntity].cs
    │   │   │   ├── IStore[TEntity].cs
    │   │   │   ├── IGamespaceStore.cs
    │   │   │   └── IWorkspaceStore.cs
    │   │   ├── Entities
    │   │   │   ├── Permission.cs
    │   │   │   ├── Extensions
    │   │   │   │   ├── Template.cs
    │   │   │   │   ├── WorkspaceExtensions.cs
    │   │   │   │   └── PermissionExtensions.cs
    │   │   │   ├── Player.cs
    │   │   │   ├── Worker.cs
    │   │   │   ├── Message.cs
    │   │   │   ├── Activity.cs
    │   │   │   ├── User.cs
    │   │   │   ├── Gamespace.cs
    │   │   │   ├── Template.cs
    │   │   │   └── Workspace.cs
    │   │   ├── Stores
    │   │   │   ├── _CachedStore.cs
    │   │   │   ├── TEntityStore.cs
    │   │   │   ├── TemplateStore.cs
    │   │   │   └── UserStore.cs
    │   │   └── TopoMojoDbContext.cs
    │   ├── Services
    │   │   ├── Mappers
    │   │   │   ├── MessageProfile.cs
    │   │   │   ├── ResolutionContext.cs
    │   │   │   ├── UserProfile.cs
    │   │   │   ├── TemplateProfile.cs
    │   │   │   ├── GamespaceProfile.cs
    │   │   │   └── WorkspaceProfile.cs
    │   │   ├── IdentityService.cs
    │   │   ├── _Service.cs
    │   │   └── UserService.cs
    │   ├── Extensions
    │   │   ├── SearchExtensions.cs
    │   │   ├── Gamespace.cs
    │   │   └── TemplateExtensions.cs
    │   ├── TopoMojo.Core.csproj
    │   ├── Exceptions.cs
    │   └── CoreOptions.cs
    └── TopoMojo.vSphere
    │   ├── TopoMojo.vSphere.csproj
    │   ├── VimReferences.cs
    │   ├── VimHelpers.cs
    │   ├── INetworkManager.cs
    │   └── DatastorePath.cs
├── test
    ├── TopoMojo.Core.Tests
    │   ├── IdentityResolver.cs
    │   ├── StubMemoryCache.cs
    │   ├── TopoMojo.Core.Tests.csproj
    │   ├── StubDistributedCache.cs
    │   ├── CoreTest.cs
    │   ├── TopoTest.cs
    │   └── TemplateTests.cs
    └── local.http
├── .github
    └── workflows
    │   └── main.yml
├── Dockerfile
├── Readme.md
└── LICENSE.md


/docs/appliance/vols/entry.d/99-entry-complete.sh:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 | 
3 | echo $0 $(date)
4 | 


--------------------------------------------------------------------------------
/docs/appliance/vols/identity-conf/identity-ui-settings.json:
--------------------------------------------------------------------------------
1 | {
2 |     "applicationName": "Foundry ID",
3 |     "apiUrl": "https://id.foundry.local"
4 | }
5 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/seed-data.json.example:
--------------------------------------------------------------------------------
1 | {
2 |     "Users": [
3 |         {
4 |             "GlobalId": "9fd3c38e-58b0-4af1-80d1-1895af91f1f9",
5 |             "Name": "Administrator",
6 |             "IsAdmin": true
7 |         }
8 |     ]
9 | }


--------------------------------------------------------------------------------
/docs/appliance/cfssl/scripts/meta-ca.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "names": [
 3 |         {
 4 | 	    "organization": "Local Foundry Root CA"
 5 |         }
 6 |     ],
 7 |     "key": {
 8 |         "algo": "rsa",
 9 |         "size": 2048
10 |     },
11 |     "CN": "Local Foundry Root CA"
12 | }
13 | 


--------------------------------------------------------------------------------
/docs/appliance/vols/entry.d/entrypoint:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | set -e
 3 | 
 4 | if [ -z "$ENTRY_DIR" ]; then ENTRY_DIR=/entry.d; fi
 5 | 
 6 | for f in $(find $ENTRY_DIR/*.sh); do
 7 |     echo [entrypoint] running $f ...
 8 |     chmod 755 $f
 9 |     $f
10 | done
11 | 
12 | exec "$@"
13 | 
14 | 


--------------------------------------------------------------------------------
/docs/appliance/scripts/start.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | ## ensure certificates generates before running containers
 3 | 
 4 | cfssl=/home/admin/appliance/cfssl
 5 | 
 6 | if [ ! -e "$cfssl/output/appliance.pem" ]; then
 7 |     /bin/bash $cfssl/setup.sh
 8 | fi
 9 | 
10 | /usr/local/bin/docker-compose up -d
11 | 


--------------------------------------------------------------------------------
/docs/appliance/cfssl/scripts/meta-int.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "names": [
 3 |         {
 4 |             "C": "US",
 5 |             "O": "Local Foundry Authority"
 6 |         }
 7 |     ],
 8 |     "key": {
 9 |         "algo": "rsa",
10 |         "size": 2048
11 |     },
12 |     "CN": "Local Foundry Authority"
13 | }
14 | 


--------------------------------------------------------------------------------
/docs/appliance/cfssl/scripts/meta-host.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "names": [
 3 |         {
 4 |             "C": "US"
 5 |         }
 6 |     ],
 7 |     "key": {
 8 |         "algo": "rsa",
 9 |         "size": 2048
10 |     },
11 |     "CN": "Application Host",
12 |     "hosts": [
13 |         "foundry.local",
14 |         "*.foundry.local"
15 |     ]
16 | }
17 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/Exceptions/Exceptions.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System;
 5 | 
 6 | namespace TopoMojo.Web
 7 | {
 8 |     public class AuthenticationFailedException : Exception {}
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/Models/DocumentModels.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | namespace TopoMojo.Web.Models
 5 | {
 6 |     public class ImageFile
 7 |     {
 8 |         public string Filename { get; set; }
 9 |     }
10 | }
11 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Client/Options.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. 
 2 | // Released under a MIT (SEI) license. See LICENSE.md in the project root. 
 3 | 
 4 | namespace TopoMojo.Client
 5 | {
 6 |     public class Options
 7 |     {
 8 |         public string Url { get; set; }
 9 |         public string Key { get; set; }
10 |         public int MaxRetries { get; set; } = 2;
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Abstractions/Models/Client.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. 
 2 | // Released under a MIT (SEI) license. See LICENSE.md in the project root. 
 3 | 
 4 | namespace TopoMojo.Models
 5 | {
 6 |     public class Client
 7 |     {
 8 |         public string Id { get; set; }
 9 |         public string Scope { get; set; }
10 |         public string Url { get; set; }
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Core/Data/Abstractions/IStoreUserContext.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | namespace TopoMojo.Data.Abstractions
 5 | {
 6 |     public interface IStoreUserContext
 7 |     {
 8 |         int UserId { get; set; }
 9 |         bool UserIsAdmin { get; set; }
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Core/Data/Entities/Permission.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System;
 5 | 
 6 | namespace TopoMojo.Data
 7 | {
 8 |     [Flags]
 9 |     public enum Permission {
10 |         None =      0,
11 |         Editor =    0x01,
12 |         Manager =   0xff
13 |     }
14 | 
15 | }
16 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Abstractions/Interfaces/IIdentityResolver.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using TopoMojo.Models;
 5 | 
 6 | namespace TopoMojo.Abstractions
 7 | {
 8 |     public interface IIdentityResolver
 9 |     {
10 |         User User { get; }
11 |         Client Client { get; }
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Core/Data/Abstractions/IEntity.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | namespace TopoMojo.Data.Abstractions
 5 | {
 6 |     public interface IEntity
 7 |     {
 8 |         int Id { get; set; }
 9 |         string GlobalId { get; set; }
10 |         System.DateTime WhenCreated { get; set; }
11 |     }
12 | 
13 | }
14 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Abstractions/Models/JanitorReport.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. 
 2 | // Released under a MIT (SEI) license. See LICENSE.md in the project root. 
 3 | 
 4 | using System;
 5 | 
 6 | namespace TopoMojo.Models
 7 | {
 8 |     public class JanitorReport
 9 |     {
10 |         public int Id { get; set; }
11 |         public string Name { get; set; }
12 |         public string Reason { get; set; }
13 |         public DateTime Age { get; set; }
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Abstractions/Models/Document.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System;
 5 | 
 6 | namespace TopoMojo.Models
 7 | {
 8 |     public class Document
 9 |     {
10 |         public string Text { get; set; }
11 |         public string WhenSaved { get; set; }
12 |         public string Timestamp { get; set; }
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Core/Data/Entities/Extensions/Template.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | namespace TopoMojo.Data.Extensions
 5 | {
 6 |     public static class TemplateExtensions
 7 |     {
 8 |         public static bool IsLinked(this Template template)
 9 |         {
10 |             return template.ParentId != null;
11 |         }
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Abstractions/Models/ConsoleSummary.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. 
 2 | // Released under a MIT (SEI) license. See LICENSE.md in the project root. 
 3 | 
 4 | namespace TopoMojo.Models
 5 | {
 6 |     public class ConsoleSummary
 7 |     {
 8 |         public string Id { get; set; }
 9 |         public string IsolationId { get; set; }
10 |         public string Name { get; set; }
11 |         public string Url { get; set; }
12 |         public bool IsRunning { get; set; }
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/Options/DatabaseOptions.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | namespace TopoMojo.Web
 5 | {
 6 |     public class DatabaseOptions
 7 |     {
 8 |         public string Provider { get; set; } = "InMemory";
 9 |         public string ConnectionString { get; set; } = "topomojo_db";
10 |         public string SeedFile { get; set; } = "seed-data.json";
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Core/Data/Abstractions/IUserStore.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System.Threading.Tasks;
 5 | using TopoMojo.Models;
 6 | 
 7 | namespace TopoMojo.Data.Abstractions
 8 | {
 9 |     public interface IUserStore : IDataStore<User>
10 |     {
11 |         Task<User> LoadDetail(int id);
12 |         Task<bool> MemberOf(string globalId, Models.User profile);
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/Options/CacheOptions.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University.
 2 | // Released under a MIT (SEI) license. See LICENSE.md in the project root.
 3 | 
 4 | namespace TopoMojo.Web
 5 | {
 6 |     public class CacheOptions
 7 |     {
 8 |         public string Key { get; set; }
 9 |         public string RedisUrl { get; set; }
10 |         public string SharedFolder { get; set; }
11 |         public string DataProtectionFolder { get; set; } = ".dpk";
12 |         public int CacheExpirationSeconds { get; set; } = 300;
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/Options/FileUploadOptions.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | namespace TopoMojo.Web
 5 | {
 6 |     public class FileUploadOptions
 7 |     {
 8 |         public long MaxFileBytes { get; set; }
 9 |         public string IsoRoot { get; set; } = "tm";
10 |         public string TopoRoot { get; set; } = "tm";
11 |         public string DocRoot { get; set; } = "tm/_docs";
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/docs/appliance/vols/entry.d/01-trust-certs.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | echo running $0
 3 | set -e
 4 | if [ -z "$ENTRY_DIR" ]; then ENTRY_DIR=/entry.d; fi
 5 | 
 6 | dst=/etc/pki/ca-trust/source/anchors
 7 | if [ -d "$dst" ]; then
 8 |     echo "updating trusted certificates (rhel)"
 9 |     cp -f $ENTRY_DIR/*.crt $dst | true
10 |     update-ca-trust
11 | fi
12 | 
13 | dst=/usr/local/share/ca-certificates
14 | if [ -d "$dst" ]; then
15 |     echo "updating trusted certificates (debian)"
16 |     cp -f $ENTRY_DIR/*.crt $dst | true
17 |     update-ca-certificates
18 | fi
19 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Abstractions/Models/Search.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | namespace TopoMojo.Models
 5 | {
 6 |     public class Search
 7 |     {
 8 |         public string Term { get; set; }
 9 |         public int Skip { get; set; }
10 |         public int Take { get; set; }
11 |         public string Sort { get; set; }
12 |         public string[] Filter { get; set; } = new string[] {};
13 |     }
14 | 
15 | }
16 | 


--------------------------------------------------------------------------------
/docs/appliance/scripts/enable-apphost.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | ## auto start / stop with systemd
 3 | 
 4 | cat <<EOF > /etc/systemd/system/appliance.service
 5 | [Unit]
 6 | Description=Control appliance stack
 7 | Requires=docker.service
 8 | After=docker.service
 9 | 
10 | [Service]
11 | Type=oneshot
12 | RemainAfterExit=yes
13 | WorkingDirectory=/home/admin/appliance
14 | ExecStart=/bin/bash scripts/start.sh
15 | ExecStop=/usr/local/bin/docker-compose down
16 | 
17 | [Install]
18 | WantedBy=multi-user.target
19 | 
20 | EOF
21 | 
22 | systemctl daemon-reload
23 | systemctl enable appliance
24 | 


--------------------------------------------------------------------------------
/docs/appliance/vols/nginx/conf.d/connect.conf:
--------------------------------------------------------------------------------
 1 | 
 2 | server {
 3 |     server_name  connect.*;
 4 |     listen       443 ssl http2;
 5 |     listen       [::]:443 ssl http2;
 6 | 
 7 |     location /ticket {
 8 |         proxy_pass https://$arg_vmhost$uri;
 9 |         proxy_http_version 1.1;
10 |         proxy_set_header Upgrade $http_upgrade;
11 |         proxy_set_header Connection "upgrade";
12 |         proxy_request_buffering off;
13 |         proxy_buffering off;
14 |         proxy_read_timeout 86400s;
15 |         proxy_send_timeout 86400s;
16 |         proxy_ssl_session_reuse on;
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/Models/DbSeedModel.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | namespace TopoMojo.Web.Models
 5 | {
 6 |     public class DbSeedModel
 7 |     {
 8 |         public DbSeedUser[] Users { get; set; } = new DbSeedUser[] {};
 9 |     }
10 | 
11 |     public class DbSeedUser
12 |     {
13 |         public string Name { get; set; }
14 |         public string GlobalId { get; set; }
15 |         public bool IsAdmin { get; set; }
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/test/TopoMojo.Core.Tests/IdentityResolver.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2019 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using TopoMojo.Abstractions;
 5 | using TopoMojo.Models;
 6 | 
 7 | namespace Tests
 8 | {
 9 |     public class IdentityResolver : IIdentityResolver
10 |     {
11 |         public IdentityResolver(User user)
12 |         {
13 |             User = user;
14 |         }
15 | 
16 |         public User User { get; }
17 |         public Client Client { get; }
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Abstractions/TopoMojo.Abstractions.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk">
 2 | 
 3 |   <PropertyGroup>
 4 |     <TargetFramework>netstandard2.0</TargetFramework>
 5 |     <Authors>Jeff Mattson</Authors>
 6 |     <Company>Software Engineering Institute</Company>
 7 |     <Copyright>Copyright 2020 Carnegie Mellon University.</Copyright>
 8 |     <PackageId>TopoMojo.Abstractions</PackageId>
 9 |     <PackageLicenseExpression>MIT</PackageLicenseExpression>
10 |     <RepositoryUrl>https://github.com/cmu-sei/TopoMojo</RepositoryUrl>
11 |     <Version>1.3.6</Version>
12 |   </PropertyGroup>
13 | 
14 | </Project>
15 | 


--------------------------------------------------------------------------------
/.github/workflows/main.yml:
--------------------------------------------------------------------------------
 1 | name: CI
 2 | 
 3 | on:
 4 |   release:
 5 |     types: [ "published" ]
 6 | 
 7 | jobs:
 8 |   build:
 9 |     runs-on: ubuntu-latest
10 |     steps:
11 |     - uses: actions/checkout@v2
12 | 
13 |     - name: Build and push Docker images
14 |       uses: docker/build-push-action@v1.1.0
15 |       with:
16 |         username: ${{ secrets.DOCKERHUB_USERNAME }}
17 |         password: ${{ secrets.DOCKERHUB_PASSWORD }}
18 |         repository: cmusei/topomojo
19 |         tag_with_ref: true
20 |         push: ${{ startsWith(github.ref, 'refs/tags/') }}
21 |         build_args: "commit=${{ github.sha }}"
22 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Core/Data/Abstractions/ITemplateStore.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System.Threading.Tasks;
 5 | 
 6 | namespace TopoMojo.Data.Abstractions
 7 | {
 8 |     public interface ITemplateStore : IDataStore<Template>
 9 |     {
10 |         Task<bool> IsParentTemplate(int id);
11 |         Task<bool> AtTemplateLimit(int topoId);
12 |         Task<Template[]> ListChildren(int parentId);
13 |         Task<string> ResolveKey(string key);
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Core/Data/Entities/Player.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System;
 5 | 
 6 | namespace TopoMojo.Data
 7 | {
 8 |     public class Player
 9 |     {
10 |         public int Id { get; set; }
11 |         public int GamespaceId { get; set; }
12 |         public virtual Gamespace Gamespace { get; set; }
13 |         public int PersonId { get; set; }
14 |         public virtual User Person { get; set; }
15 |         public Permission Permission { get; set; }
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Core/Data/Entities/Worker.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System;
 5 | 
 6 | namespace TopoMojo.Data
 7 | {
 8 |     public class Worker
 9 |     {
10 |         public int Id { get; set; }
11 |         public int WorkspaceId { get; set; }
12 |         public virtual Workspace Workspace { get; set; }
13 |         public int PersonId { get; set; }
14 |         public virtual User Person { get; set; }
15 |         public Permission Permission { get; set; }
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/web.config:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <configuration>
 3 | 
 4 |   <!--
 5 |     Configure your application settings in appsettings.json. Learn more at https://go.microsoft.com/fwlink/?LinkId=786380
 6 |   -->
 7 | 
 8 |   <system.webServer>
 9 |     <handlers>
10 |       <add name="aspNetCore" path="*" verb="*" modules="AspNetCoreModuleV2" resourceType="Unspecified"/>
11 |     </handlers>
12 |     <aspNetCore processPath="%LAUNCHER_PATH%" arguments="%LAUNCHER_ARGS%" stdoutLogEnabled="false" stdoutLogFile=".\logs\stdout" forwardWindowsAuthToken="false"/>
13 |   </system.webServer>
14 | </configuration>
15 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Core/Services/Mappers/MessageProfile.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using AutoMapper;
 5 | using TopoMojo.Models;
 6 | 
 7 | namespace TopoMojo.Services
 8 | {
 9 |     public class MessageProfile : Profile
10 |     {
11 |         public MessageProfile()
12 |         {
13 |             CreateMap<NewMessage, Data.Message>();
14 | 
15 |             CreateMap<ChangedMessage, Data.Message>();
16 | 
17 |             CreateMap<Data.Message, Message>();
18 |         }
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Core/Services/Mappers/ResolutionContext.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using TopoMojo.Models;
 5 | 
 6 | namespace TopoMojo.Services
 7 |  {
 8 |     public static class ResolutionContextExtensions
 9 |     {
10 |         public static User GetActor(this AutoMapper.ResolutionContext res)
11 |         {
12 |             if (res.Items.ContainsKey("Actor"))
13 |                 return res.Items["Actor"] as User;
14 | 
15 |             return new User();
16 |         }
17 |     }
18 |  }
19 | 


--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
 1 | #
 2 | #multi-stage target: dev
 3 | #
 4 | FROM mcr.microsoft.com/dotnet/core/sdk:3.1 AS dev
 5 | 
 6 | ENV ASPNETCORE_URLS=http://*:5000 \
 7 |     ASPNETCORE_ENVIRONMENT=DEVELOPMENT
 8 | 
 9 | COPY . /app
10 | 
11 | WORKDIR /app/src/TopoMojo.Web
12 | RUN dotnet publish -c Release -o /app/dist
13 | CMD ["dotnet", "run"]
14 | 
15 | #
16 | #multi-stage target: prod
17 | #
18 | FROM mcr.microsoft.com/dotnet/core/aspnet:3.1 AS prod
19 | ARG commit
20 | ENV COMMIT=$commit
21 | COPY --from=dev /app/dist /app
22 | COPY --from=dev /app/LICENSE.md /app/LICENSE.md
23 | WORKDIR /app
24 | EXPOSE 80
25 | ENV ASPNETCORE_URLS=http://*:80
26 | CMD [ "dotnet", "TopoMojo.Web.dll" ]
27 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Core/Extensions/SearchExtensions.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System.Linq;
 5 | 
 6 | namespace TopoMojo.Models
 7 | {
 8 |     public static class SearchExtensions
 9 |     {
10 |         public static bool HasFilter(this Search search, string name)
11 |         {
12 |             return search.Filter.Any(f => f == name);
13 |         }
14 | 
15 |         public static string GetFilter(this Search search, string name)
16 |         {
17 |             return search.Filter.FirstOrDefault(f => f == name);
18 |         }
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/Extensions/ClaimsPrincipalExtensions.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University.
 2 | // Released under a MIT (SEI) license. See LICENSE.md in the project root.
 3 | 
 4 | using System.Security.Claims;
 5 | using TopoMojo.Web;
 6 | 
 7 | namespace TopoMojo
 8 | {
 9 |     public static class ClaimsPrincipalExtensions
10 |     {
11 |         public static string Subject(this ClaimsPrincipal user)
12 |         {
13 |             return user.FindFirstValue(AppConstants.SubjectClaimName);
14 |         }
15 | 
16 |         public static string Name(this ClaimsPrincipal user)
17 |         {
18 |             return user.FindFirstValue(AppConstants.NameClaimName);
19 |         }
20 | 
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Core/Data/Entities/Message.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System;
 5 | using TopoMojo.Data.Abstractions;
 6 | 
 7 | namespace TopoMojo.Data
 8 | {
 9 |     public class Message
10 |     {
11 |         public int Id { get; set; }
12 |         public string RoomId { get; set; }
13 |         public string Text { get; set; }
14 |         public bool Edited { get; set; }
15 |         public DateTime WhenCreated { get; set; }
16 |         public int AuthorId { get; set; }
17 |         public string AuthorName { get; set; }
18 |     }
19 | 
20 | }
21 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Core/Data/Abstractions/IDataStore[TEntity].cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University.
 2 | // Released under a MIT (SEI) license. See LICENSE.md in the project root.
 3 | 
 4 | using System;
 5 | using System.Linq;
 6 | using System.Threading.Tasks;
 7 | 
 8 | namespace TopoMojo.Data.Abstractions
 9 | {
10 |     public interface IDataStore<TEntity>
11 |         where TEntity : class
12 |     {
13 |         IQueryable<TEntity> List(string term = null);
14 |         Task<TEntity> Load(int id);
15 |         Task<TEntity> Load(string id);
16 |         Task<TEntity> Add(TEntity entity);
17 |         Task Update(TEntity entity);
18 |         Task Delete(int id);
19 |         Task<bool> Exists(int id);
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Core/Services/Mappers/UserProfile.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using AutoMapper;
 5 | using TopoMojo.Models;
 6 | 
 7 | namespace TopoMojo.Services
 8 | {
 9 |     public class UserProfile : Profile
10 |     {
11 |         public UserProfile()
12 |         {
13 |             CreateMap<Data.User, User>()
14 | 
15 |                 .ForMember(d => d.WhenCreated, opt => opt.MapFrom(s => s.WhenCreated.ToString("u")))
16 | 
17 |                 .ReverseMap()
18 |             ;
19 | 
20 |             CreateMap<ChangedUser, Data.User>();
21 |         }
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/migration-undo.ps1:
--------------------------------------------------------------------------------
 1 | <# Copyright 2020 Carnegie Mellon University. #>
 2 | <# Released under a MIT (SEI) license. See LICENSE.md in the project root. #>
 3 | 
 4 | <#
 5 | .Synopsis Remove last migration for multiple database providers
 6 | .Notes
 7 |     From the project root, pass in the context.
 8 |     If you just have a single context, assign it to the parameter
 9 | .Example
10 |     ./Data/migrations-undo.ps1 ClientDb
11 | #>
12 | Param(
13 |     [Parameter(Mandatory = $true)]
14 |     $context
15 | )
16 | 
17 | $providers = @('SqlServer', 'PostgreSQL')
18 | foreach ($provider in $providers) {
19 |     $env:Database:Provider=$provider
20 |     dotnet ef migrations remove --context "$($context)Context$($provider)" -f
21 | }
22 | $env:Database:Provider=''
23 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/migration-undo.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | #
 3 | # .Synopsis Remove last migration for multiple database providers
 4 | # .Notes
 5 | #     From the project root, pass in the context.
 6 | #     If you just have a single context, assign it to the parameter
 7 | # .Example
 8 | #     ./Data/migrations-undo.ps1 ClientDb
 9 | #
10 | 
11 | if [ "$#" -ne 1 ]; then
12 |     echo "usage: $0 db-context"
13 |     exit 1
14 | fi
15 | 
16 | context=${1%Context}
17 | declare -a providers=("SqlServer" "PostgreSQL")
18 | 
19 | for provider in "${providers[@]}"; do
20 |     export Database__Provider=$provider
21 |     echo $provider $context
22 |     dotnet ef migrations remove --context ${context}Context${provider} -f
23 |     wait
24 | done
25 | 
26 | export Database__Provider=
27 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/Infrastructure/HubCache.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System.Collections.Concurrent;
 5 | 
 6 | namespace TopoMojo.Web.Services
 7 | {
 8 |     public class HubCache
 9 |     {
10 |         public ConcurrentDictionary<string,CachedConnection> Connections { get; } = new ConcurrentDictionary<string,CachedConnection>();
11 |     }
12 | 
13 |     public class CachedConnection
14 |     {
15 |         public string Id { get; set; }
16 |         public string Room { get; set; }
17 |         public string ProfileId { get; set; }
18 |         public string ProfileName { get; set; }
19 |     }
20 | 
21 | }
22 | 


--------------------------------------------------------------------------------
/docs/appliance/cfssl/setup.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | path=/home/admin/appliance
 4 | certs=$path/cfssl/output
 5 | 
 6 | docker run --rm -v $path/cfssl:/opt/cfssl cfssl -c "sh scripts/generate-certificate.sh $@"
 7 | 
 8 | cat $certs/appliance.pem $certs/appliance-int.pem > $path/vols/nginx/conf.d/appliance.pem
 9 | cp $certs/appliance-key.pem $path/vols/nginx/conf.d/appliance-key.pem
10 | cp $certs/appliance-ca.pem $path/vols/nginx/html/ca.pem
11 | cp $certs/appliance-ca.pem $path/vols/entry.d/appliance-ca.crt
12 | cp $certs/appliance-int.pem $path/vols/entry.d/appliance-int.crt
13 | 
14 | openssl pkcs12 -export \
15 |     -in $certs/appliance.pem \
16 |     -inkey $certs/appliance-key.pem \
17 |     -out $path/vols/identity-conf/signer.pfx \
18 |     -nodes \
19 |     -passout pass:
20 | 


--------------------------------------------------------------------------------
/docs/appliance/cfssl/scripts/generate-certificate.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | cd /opt/cfssl/scripts
 4 | 
 5 | if [ ! -f appliance-ca.pem ]; then
 6 |     cfssl gencert -initca meta-ca.json | cfssljson -bare appliance-ca
 7 | fi
 8 | 
 9 | if [ ! -f appliance-int.pem ]; then
10 |     cfssl gencert -ca appliance-ca.pem -ca-key appliance-ca-key.pem -config config.json -profile intca meta-int.json | cfssljson -bare appliance-int
11 | fi
12 | 
13 | echo [$1]
14 | cp meta-host.json customhost.json
15 | if [ -n "$1" ];then sed -i s,foundry.local,$1, customhost.json; fi
16 | cfssl gencert -ca appliance-int.pem -ca-key appliance-int-key.pem -config config.json -profile server customhost.json | cfssljson -bare appliance
17 | 
18 | mkdir -p ../output
19 | cp *.pem ../output
20 | chown 1000:1000 ../output/*
21 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Core/Data/Entities/Extensions/WorkspaceExtensions.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. 
 2 | // Released under a MIT (SEI) license. See LICENSE.md in the project root. 
 3 | 
 4 | using System;
 5 | using System.Linq;
 6 | 
 7 | namespace TopoMojo.Data.Extensions
 8 | {
 9 |     public static class WorkspaceExtensions
10 |     {
11 |         public static bool HasScope(this Workspace workspace, string scope)
12 |         {
13 |             var delims = new char[] { ' ', ',', ';' };
14 | 
15 |             var client = scope.Split(delims, StringSplitOptions.RemoveEmptyEntries);
16 | 
17 |             var resource = workspace.Audience.Split(delims, StringSplitOptions.RemoveEmptyEntries);
18 | 
19 |             return client.Intersect(resource).Any();
20 |         }
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/docs/appliance/vols/nginx/conf.d/default.conf:
--------------------------------------------------------------------------------
 1 | 
 2 | server {
 3 |     listen       80 default_server;
 4 |     listen       [::]:80 default_server;
 5 |     server_name  _;
 6 | 
 7 |     location /.well-known {
 8 |     }
 9 | 
10 |     location / {
11 |         return 301 https://$host$request_uri;
12 |     }
13 | }
14 | 
15 | server {
16 |     listen       443 ssl http2 default_server;
17 |     listen       [::]:443 ssl http2 default_server;
18 |     server_name  _;
19 | 
20 |     location / {
21 |         try_files $uri /index.html;
22 |         # return 301 https://topomojo.foundry.local$request_uri;
23 |     }
24 | 
25 |     error_page 404 /404.html;
26 |         location = /40x.html {
27 |     }
28 | 
29 |     error_page 500 502 503 504 /50x.html;
30 |         location = /50x.html {
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Core/Data/Abstractions/IStore[TEntity].cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System.Linq;
 5 | using System.Threading.Tasks;
 6 | 
 7 | namespace TopoMojo.Data.Abstractions
 8 | {
 9 |     public interface IStore<TEntity>
10 |         where TEntity : class, IEntity
11 |     {
12 |         Task<TEntity> Add(TEntity entity);
13 |         Task<bool> CanEdit(int id, User profile);
14 |         Task<bool> CanManage(int id, User profile);
15 |         IQueryable<TEntity> List();
16 |         Task<TEntity> Load(int id);
17 |         Task<TEntity> FindByGlobalId(string guid);
18 |         Task Remove(TEntity entity);
19 |         Task Update(TEntity entity);
20 | 
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/Extensions/FileUploadStartupExtensions.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. 
 2 | // Released under a MIT (SEI) license. See LICENSE.md in the project root. 
 3 | 
 4 | using TopoMojo.Web;
 5 | using TopoMojo.Web.Services;
 6 | 
 7 | namespace Microsoft.Extensions.DependencyInjection
 8 | {
 9 |     public static class FileUploadStartupExtensions
10 |     {
11 |         public static IServiceCollection AddFileUpload(
12 |             this IServiceCollection services,
13 |             FileUploadOptions options
14 |         )
15 |         {
16 |             return services
17 |                 .AddScoped<IFileUploadHandler, FileUploadHandler>()
18 |                 .AddSingleton<FileUploadOptions>(_ => options)
19 |                 .AddSingleton<IFileUploadMonitor, FileUploadMonitor>();
20 |         }
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Core/Data/Abstractions/IGamespaceStore.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System;
 5 | using System.Linq;
 6 | using System.Threading.Tasks;
 7 | 
 8 | namespace TopoMojo.Data.Abstractions
 9 | {
10 |     public interface IGamespaceStore : IDataStore<Gamespace>
11 |     {
12 |         Task<Gamespace> FindByContext(int topoId, int profileId);
13 |         Task<Gamespace> FindByPlayer(int playerId);
14 |         Task<Gamespace> FindByShareCode(string code);
15 |         IQueryable<Gamespace> ListByProfile(int id);
16 |         IQueryable<Gamespace> ListByProfile(string id);
17 |         Task<Gamespace[]> DeleteStale(DateTime staleAfter, bool dryrun = true);
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Core/Data/Abstractions/IWorkspaceStore.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System;
 5 | using System.Threading.Tasks;
 6 | 
 7 | namespace TopoMojo.Data.Abstractions
 8 | {
 9 |     public interface IWorkspaceStore : IDataStore<Workspace>
10 |     {
11 |         Task<Workspace> FindByShareCode(string code);
12 |         Task<Workspace> FindByWorker(int id);
13 |         Task<int> GetWorkspaceCount(int profileId);
14 |         Task<Workspace> LoadWithGamespaces(int id);
15 |         Task<Workspace> LoadWithParents(int id);
16 |         Task<bool> HasGames(int id);
17 |         Task<Workspace[]> DeleteStale(DateTime staleAfter, bool published, bool dryrun = true);
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/docs/appliance/vols/identity-conf/notice.html:
--------------------------------------------------------------------------------
 1 | 
 2 | <h4>
 3 |     Cookie Policy
 4 | </h4>
 5 | <p class="text-left">
 6 |     This site uses browser cookies for authentication. When you login, we add a cookie that gets sent back to this server with each request for the duration of your session.  That's so you don't have to login to view <i>every</i> page.
 7 | </p>
 8 | 
 9 | <h4>
10 |     Privacy Policy
11 | </h4>
12 | <p class="text-left">
13 |     We store your email address, and if you provide them, your name and organization name.  This information is available to site administrators for the purpose of analyzing participation and communicating with participants.
14 | </p>
15 | 
16 | <h4>
17 |     Terms of Service
18 | </h4>
19 | <p class="text-left">
20 |     Use is "AS IS", and the authors and hosts accept no liability stemming from your use of it.
21 | </p>
22 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Core/TopoMojo.Core.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk">
 2 |   <PropertyGroup>
 3 |     <TargetFramework>netcoreapp3.1</TargetFramework>
 4 |   </PropertyGroup>
 5 |   <ItemGroup>
 6 |     <ProjectReference Include="../TopoMojo.Abstractions/TopoMojo.Abstractions.csproj" />
 7 |   </ItemGroup>
 8 |   <ItemGroup>
 9 |     <FrameworkReference Include="Microsoft.AspNetCore.App" Version="3.1" />
10 |     <PackageReference Include="AutoMapper" Version="9.0.0" />
11 |     <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="3.1" />
12 |     <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="3.1" />
13 |     <PackageReference Include="NewtonSoft.Json" Version="12.0.3" />
14 |     <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="3.1.4
15 |     " />
16 |   </ItemGroup>
17 | </Project>
18 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/migration-add.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | #
 3 | # .Synopsis Add a migration for multiple database providers
 4 | # .Notes
 5 | #     From the project root, pass in this context and migration name.
 6 | #     If you only have a single context, assign it to the parameter.
 7 | # .Example
 8 | #     ./Data/migrations-add.ps1 TestMigr ClientDb
 9 | #
10 | 
11 | if [ "$#" -ne 2 ]; then
12 |     echo "usage: $0 migration-name db-context"
13 |     exit 1
14 | fi
15 | 
16 | name=$1
17 | context=${2%Context}
18 | declare -a providers=("SqlServer" "PostgreSQL")
19 | 
20 | for provider in "${providers[@]}"; do
21 |     export Database__Provider=$provider
22 |     echo $provider $name $context
23 |     dotnet ef migrations add $name --context ${context}Context${provider} -o ./Data/Migrations/$provider/${context}
24 |     wait
25 | done
26 | 
27 | export Database__Provider=
28 | 


--------------------------------------------------------------------------------
/src/TopoMojo.vSphere/TopoMojo.vSphere.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk">
 2 | 
 3 |   <PropertyGroup>
 4 |     <TargetFramework>netstandard2.0</TargetFramework>
 5 |     <DebugType>portable</DebugType>
 6 |     <AssemblyName>TopoMojo.vSphere</AssemblyName>
 7 |     <PackageId>TopoMojo.vSphere</PackageId>
 8 |     <Version>1.2.0</Version>
 9 |   </PropertyGroup>
10 | 
11 |   <ItemGroup>
12 |     <ProjectReference Include="../TopoMojo.Abstractions/TopoMojo.Abstractions.csproj" />
13 |   </ItemGroup>
14 | 
15 |   <ItemGroup>
16 |     <PackageReference Include="NetVimClient" Version="6.7.0" />
17 |     <PackageReference Include="Microsoft.Extensions.Logging" Version="3.1.0" />
18 |     <PackageReference Include="Microsoft.Extensions.Hosting" Version="3.1.0" />
19 |     <PackageReference Include="System.Net.Http" Version="4.3.4" />
20 |   </ItemGroup>
21 | 
22 | </Project>
23 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/AppConstants.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University.
 2 | // Released under a MIT (SEI) license. See LICENSE.md in the project root.
 3 | 
 4 | namespace TopoMojo.Web
 5 | {
 6 |     internal static class AppConstants
 7 |     {
 8 |         public const string Audience = "topomojo-api";
 9 |         public const string PrivilegedAudience = "topomojo-api-privileged";
10 |         public const string PrivilegedPolicy = "topomojo-api-privileged";
11 |         public const string DataProtectionPurpose = "_dp:TopoMojo";
12 |         public const string SubjectClaimName = "sub";
13 |         public const string NameClaimName = "name";
14 |         public const string RegistrationCachePrefix = "lp:";
15 |         public const string CookieScheme = ".TopoMojo.Cookies";
16 |     }
17 | 
18 |     internal static class AuditId
19 |     {
20 | 
21 |     }
22 | 
23 | }
24 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Core/Data/Entities/Activity.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System;
 5 | 
 6 | namespace TopoMojo.Data
 7 | {
 8 |     public class Activity
 9 |     {
10 |         public int Id { get; set; }
11 |         public int ActorId { get; set; }
12 |         public int AssetId { get; set; }
13 |         public ActivityType Action { get; set; }
14 |         public DateTime At { get; set; }
15 |         public string Actor { get; set; }
16 |         public string Asset { get; set; }
17 |         public string Annotation { get; set; }
18 |     }
19 | 
20 |     public enum ActivityType
21 |     {
22 |         Created,
23 |         Deleted,
24 |         Published,
25 |         Unpublished,
26 |         Launched
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/Extensions/IdentityExtensions.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University.
 2 | // Released under a MIT (SEI) license. See LICENSE.md in the project root.
 3 | 
 4 | using System.IdentityModel.Tokens.Jwt;
 5 | using System.Security.Claims;
 6 | using TopoMojo.Models;
 7 | 
 8 | namespace TopoMojo.Web.Extensions
 9 | {
10 |     public static class IdentityExtensions
11 |     {
12 |         public static ClaimsPrincipal AddUserClaims(this ClaimsPrincipal principal, User user)
13 |         {
14 |             ((ClaimsIdentity)principal.Identity).AddClaims(new Claim[]
15 |             {
16 |                 new Claim(JwtRegisteredClaimNames.NameId, user.Id.ToString()),
17 |                 new Claim("name", user.Name),
18 |                 new Claim("role", user.Role.ToString().ToLower())
19 |             });
20 | 
21 |             return principal;
22 |         }
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/docs/appliance/cfssl/Readme.md:
--------------------------------------------------------------------------------
 1 | # Appliance Certificate Management
 2 | 
 3 | This is a convenience tool for generating realistic certificates in offline environments.
 4 | It constructs a root and intermediate CA, and provides an *appliance* wildcard certificate
 5 | for your host/web-server.
 6 | 
 7 | ## Setup
 8 | 
 9 | The `setup.sh` will create the cert chain if it doesn't exist.
10 | By default, it will create a certificate for `foundry.local`.
11 | You can customize it by passing in a different domain, e.g. `./setup.sh example.com`
12 | 
13 | To modify the Root and Intermediate certificate names, use the `scripts/ca.json` and `scripts/int.json` files.
14 | Init won't overwrite existing int/ca certs, so delete the `scripts/*.pem` files if you want to start over.
15 | Init will overwrite the appliance cert, and distribute it throughout the app.
16 | 
17 | ```bash
18 | > setup.sh [domain]
19 | ```
20 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Abstractions/Models/Message.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | namespace TopoMojo.Models
 5 | {
 6 |     public class NewMessage
 7 |     {
 8 |         public string RoomId { get; set; }
 9 |         public string Text { get; set; }
10 |     }
11 | 
12 |     public class ChangedMessage
13 |     {
14 |         public int Id { get; set; }
15 |         public string Text { get; set; }
16 | 
17 |     }
18 | 
19 |     public class Message
20 |     {
21 |         public int Id { get; set; }
22 |         public string RoomId { get; set; }
23 |         public string AuthorName { get; set; }
24 |         public string Text { get; set; }
25 |         public string WhenCreated { get; set; }
26 |         public bool Edited { get; set; }
27 | 
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/test/local.http:
--------------------------------------------------------------------------------
 1 | @api = http://localhost:5004/api
 2 | # @api = https://topomojo.cyberforce.site/api
 3 | @json = Content-Type: application/json
 4 | 
 5 | ###
 6 | GET {{api}}/workspaces
 7 | 
 8 | 
 9 | ###
10 | POST http://localhost:5000/api/resource/devimport
11 | {{json}}
12 | 
13 | {
14 |     "Apis": [ "topomojo-api" ],
15 |     "Clients": [
16 |         {
17 |             "Id": "topomojo-ui",
18 |             "DisplayName": "",
19 |             "GrantType": "authorization_code",
20 |             "Scopes": "openid profile topomojo-api",
21 |             "Secret": "",
22 |             "RedirectUrl": "http://localhost:4200/oidc"
23 |         },
24 |         {
25 |             "Id": "topomojo-swagger",
26 |             "GrantType": "authorization_code",
27 |             "Scopes": "openid topomojo-api",
28 |             "RedirectUrl": "http://localhost:5004/api/oauth2-redirect.html"
29 |         }
30 |     ]
31 | }
32 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Abstractions/Interfaces/ITopoMojoClient.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University.
 2 | // Released under a MIT (SEI) license. See LICENSE.md in the project root.
 3 | 
 4 | using System;
 5 | using System.Threading.Tasks;
 6 | using TopoMojo.Models;
 7 | 
 8 | namespace TopoMojo.Abstractions
 9 | {
10 |     public interface ITopoMojoClient
11 |     {
12 |         Task<GameState> Start(GamespaceSpec workspace);
13 |         Task Stop(string problemId);
14 |         Task<ConsoleSummary> Ticket(string vmId);
15 |         Task ChangeVm(VmAction vmAction);
16 |         Task BuildIso(IsoBuildSpec spec);
17 |         Task<string> Templates(int id);
18 |         Task<WorkspaceSummary[]> List(Search search);
19 |         Task<Registration> Register(RegistrationRequest request);
20 |         Task<Challenge> Grade(Challenge challenge);
21 |         Task<Challenge> Hints(Challenge challenge);
22 |     }
23 | 
24 | }
25 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Core/Data/Entities/User.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System;
 5 | using System.Collections.Generic;
 6 | using TopoMojo.Data.Abstractions;
 7 | using TopoMojo.Models;
 8 | 
 9 | namespace TopoMojo.Data
10 | {
11 |     public class User: IEntity
12 |     {
13 |         public int Id { get; set; }
14 |         public string GlobalId { get; set; }
15 |         public string Name { get; set; }
16 |         public DateTime WhenCreated { get; set; }
17 |         public int WorkspaceLimit { get; set; }
18 |         public UserRole Role { get; set; }
19 |         public virtual ICollection<Worker> Workspaces { get; set; } = new List<Worker>();
20 |         public virtual ICollection<Player> Gamespaces { get; set; } = new List<Player>();
21 |     }
22 | 
23 | }
24 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/Infrastructure/ApiKeyAuthenticationExtensions.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. 
 2 | // Released under a MIT (SEI) license. See LICENSE.md in the project root. 
 3 | 
 4 | using System;
 5 | using Microsoft.AspNetCore.Authentication;
 6 | using TopoMojo.Web;
 7 | 
 8 | namespace Microsoft.Extensions.DependencyInjection
 9 | {
10 |     public static class ApiKeyAuthenticationExtensions
11 |     {
12 |         public static AuthenticationBuilder AddApiKey(
13 |             this AuthenticationBuilder builder,
14 |             string scheme,
15 |             Action<ApiKeyAuthenticationOptions> options
16 |         ) {
17 | 
18 |             builder.AddScheme<ApiKeyAuthenticationOptions, ApiKeyAuthenticationHandler>(
19 |                 scheme ?? ApiKeyAuthentication.AuthenticationScheme,
20 |                 options
21 |             );
22 | 
23 |             return builder;
24 |         }
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/migration-add.ps1:
--------------------------------------------------------------------------------
 1 | <# Copyright 2020 Carnegie Mellon University. #>
 2 | <# Released under a MIT (SEI) license. See LICENSE.md in the project root. #>
 3 | 
 4 | <#
 5 | .Synopsis Add a migration for multiple database providers
 6 | .Notes
 7 |     From the project root, pass in this context and migration name.
 8 |     If you only have a single context, assign it to the parameter.
 9 | .Example
10 |     ./Data/migrations-add.ps1 ClientDb TestMigr
11 | #>
12 | Param(
13 |     [Parameter(Mandatory = $true)]
14 |     $name,
15 |     [Parameter(Mandatory = $true)]
16 |     $context
17 | )
18 | 
19 | $providers = @('SqlServer', 'PostgreSQL')
20 | foreach ($provider in $providers) {
21 |     $env:Database:Provider=$provider
22 |     write-host $provider $name $context
23 |     dotnet ef migrations add $name --context "$($context)Context$($provider)" -o ./Data/Migrations/$provider/$context
24 | }
25 | 
26 | $env:Database:Provider=''
27 | 


--------------------------------------------------------------------------------
/docs/appliance/scripts/set-proxy.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | ## helper script for toggling web proxy config
 3 | 
 4 | if [ -z "$1" ]; then
 5 |  echo usage: $0 http://proxy.my.domain:8080 [no-proxy-string]
 6 |  exit
 7 | fi
 8 | 
 9 | proxy=$1
10 | noproxy=${2:-localhost,.local}
11 | 
12 | # set for shells
13 | echo "export http_proxy=$proxy" > /etc/profile.d/http_proxy.sh
14 | echo "export https_proxy=$proxy" >> /etc/profile.d/http_proxy.sh
15 | echo "export no_proxy=$noproxy" >> /etc/profile.d/http_proxy.sh
16 | 
17 | # set for yum
18 | echo proxy=$proxy >> /etc/yum.conf
19 | 
20 | # set for docker
21 | target=/etc/systemd/system/docker.service.d
22 | mkdir -p $target
23 | cat <<EOF > $target/http-proxy.conf
24 | [Service]
25 | Environment="HTTP_PROXY=$proxy"
26 | Environment="HTTPS_PROXY=$proxy"
27 | Environment="NO_PROXY=$noproxy"
28 | EOF
29 | 
30 | systemctl daemon-reload
31 | systemctl restart docker
32 | 
33 | echo Proxy set.  Please open a new shell.
34 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/Infrastructure/TicketAuthenticationExtensions.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. 
 2 | // Released under a MIT (SEI) license. See LICENSE.md in the project root. 
 3 | 
 4 | using System;
 5 | using Microsoft.AspNetCore.Authentication;
 6 | using TopoMojo.Web;
 7 | 
 8 | namespace Microsoft.Extensions.DependencyInjection
 9 | {
10 |     public static class TicketAuthenticationExtensions
11 |     {
12 |         public static AuthenticationBuilder AddTicketAuthentication(
13 |             this AuthenticationBuilder builder,
14 |             string scheme,
15 |             Action<TicketAuthenticationOptions> options
16 |         ) {
17 | 
18 |             builder.AddScheme<TicketAuthenticationOptions, TicketAuthenticationHandler>(
19 |                 scheme ?? TicketAuthentication.AuthenticationScheme,
20 |                 options
21 |             );
22 | 
23 |             return builder;
24 |         }
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/docs/appliance/scripts/ova-shutdown.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | ## clean up and shutdown for distribution
 3 | 
 4 | cd /home/admin/appliance
 5 | 
 6 | # shutdown and delete apps
 7 | docker-compose down
 8 | docker volume prune -f
 9 | 
10 | # remove yum cache
11 | yum clean all
12 | rm -rf /var/cache/yum
13 | 
14 | # remove any proxy info
15 | rm -f /etc/profile.d/http_proxy.sh
16 | rm -f /etc/systemd/system/docker.service.d/http-proxy.conf
17 | sed -i s,proxy=.*$,, /etc/yum.conf
18 | 
19 | #remove any certs
20 | rm -rf /home/admin/appliance/cfssl/output
21 | rm -f /home/admin/appliance/cfssl/scripts/*.pem
22 | rm -f /home/admin/appliance/vols/nginx/conf.d/*.pem
23 | rm -f /home/admin/appliance/vols/nginx/html/*.pem
24 | rm -f /home/admin/appliance/vols/entry.d/*.crt
25 | 
26 | # remove history
27 | rm -rf /home/admin/.ssh
28 | rm -rf /home/admin/.vscode-server
29 | rm -f /home/admin/.bash_history
30 | rm -f /root/.bash_history
31 | 
32 | history -c && shutdown -h now
33 | 


--------------------------------------------------------------------------------
/docs/appliance/vols/nginx/html/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 | <head>
 4 |   <title>Local Foundry</title>
 5 |   <style>
 6 |     body {
 7 |       background-color: black;
 8 |     }
 9 |     .jumbotron {
10 |       margin:100px;
11 |       padding:20px;
12 |       text-align: center;
13 |       border-radius: 8px;
14 |       background-color: lightgray;
15 |       font-family: Arial
16 |     }
17 |   </style>
18 | </head>
19 | 
20 | <body>
21 |   <div class="jumbotron">
22 |     <h1>Local Foundry</h1>
23 |     <p>
24 |       <a href="ca.pem">Local Foundry Root CA certificate</a>
25 |     </p>
26 |     <p>
27 |       Continue to <a href="https://topomojo.foundry.local">https://topomojo.foundry.local</a>.<br/>
28 |       <small>
29 |         (If you changed the domain, you may want to update this
30 |         link as well at /apps/vols/nginx/html/index.html)
31 |       </small>
32 |     </p>
33 |   </div>
34 | </body>
35 | 
36 | </html>
37 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Core/Extensions/Gamespace.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System.Linq;
 5 | using TopoMojo.Extensions;
 6 | 
 7 | namespace TopoMojo.Models
 8 | {
 9 |     public static class ModelExtensions
10 |     {
11 |         public static void MergeVms(this GameState state, Vm[] vms)
12 |         {
13 |             foreach (Vm vm in vms)
14 |             {
15 |                 string name = vm.Name.Untagged();
16 |                 VmState vs = state.Vms
17 |                     .Where(t => t.Name == name && !t.Id.HasValue())
18 |                     .FirstOrDefault();
19 | 
20 |                 if (vs != null)
21 |                 {
22 |                     vs.Id = vm.Id;
23 |                     vs.IsRunning = vm.State == VmPowerState.Running;
24 |                 }
25 |             }
26 |         }
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/TopoMojo.vSphere/VimReferences.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using NetVimClient;
 5 | 
 6 | namespace TopoMojo.vSphere
 7 | {
 8 |     public class VimReferences
 9 |     {
10 |         public VimPortTypeClient vim { get; set; }
11 |         public ManagedObjectReference cluster { get; set; }
12 |         public ManagedObjectReference props { get; set; }
13 |         public ManagedObjectReference pool { get; set; }
14 |         public ManagedObjectReference vmFolder { get; set; }
15 |         public ManagedObjectReference dvs { get; set; }
16 |         public ManagedObjectReference net { get; set; }
17 |         public string UplinkSwitch { get; set; }
18 |         public string DvsUuid { get; set; }
19 |         public string ExcludeNetworkMask { get; set; } = "topomojo";
20 |         public string NetworkAllowAllSuffix { get; set; } = "-aa";
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Core/Data/Entities/Gamespace.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System;
 5 | using System.Collections.Generic;
 6 | using TopoMojo.Data.Abstractions;
 7 | 
 8 | namespace TopoMojo.Data
 9 | {
10 |     public class Gamespace : IEntity
11 |     {
12 |         public int Id { get; set; }
13 |         public string GlobalId { get; set; }
14 |         public string Name { get; set; }
15 |         public DateTime WhenCreated { get; set; }
16 |         public DateTime LastActivity { get; set; }
17 |         public string ShareCode { get; set; }
18 |         public string Audience { get; set; }
19 |         public int WorkspaceId { get; set; }
20 |         public virtual Workspace Workspace { get; set; }
21 |         public string Challenge { get; set; }
22 |         public virtual ICollection<Player> Players { get; set; } = new List<Player>();
23 |     }
24 | 
25 | }
26 | 


--------------------------------------------------------------------------------
/src/TopoMojo.vSphere/VimHelpers.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System;
 5 | using NetVimClient;
 6 | 
 7 | namespace TopoMojo.vSphere.Helpers
 8 | {
 9 |     public class PortGroupAllocation
10 |     {
11 |         public string Net { get; set; }
12 |         public string Key { get; set; }
13 |         public int Counter { get; set; }
14 |         public int VlanId { get; set; }
15 |         public string Switch { get; set; }
16 |     }
17 | 
18 |     public class VmNetwork
19 |     {
20 |         public string VmName { get; set; }
21 |         public string NetworkMOR { get; set; }
22 |     }
23 | 
24 |     internal class VimHostTask
25 |     {
26 |         public ManagedObjectReference Task { get; set; }
27 |         public string Action { get; set; }
28 |         public int Progress { get; set; }
29 |         public DateTime WhenCreated { get; set; }
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/test/TopoMojo.Core.Tests/StubMemoryCache.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. 
 2 | // Released under a MIT (SEI) license. See LICENSE.md in the project root. 
 3 | 
 4 | using System.Collections.Generic;
 5 | using Microsoft.Extensions.Caching.Memory;
 6 | 
 7 | namespace Tests
 8 | {
 9 |     public class StubMemoryCache : IMemoryCache
10 |     {
11 |         Dictionary<object, object> _cache = new Dictionary<object, object>();
12 | 
13 |         public ICacheEntry CreateEntry(object key)
14 |         {
15 |             throw new System.NotImplementedException();
16 |         }
17 | 
18 |         public void Dispose()
19 |         {
20 |             throw new System.NotImplementedException();
21 |         }
22 | 
23 |         public void Remove(object key)
24 |         {
25 |             throw new System.NotImplementedException();
26 |         }
27 | 
28 |         public bool TryGetValue(object key, out object value)
29 |         {
30 |             throw new System.NotImplementedException();
31 |         }
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/docs/appliance/vols/topomojo-conf/topomojo-ui-settings.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "branding": {
 3 |       "applicationName": "TopoMojo",
 4 |       "logoUrl": ""
 5 |     },
 6 | 
 7 |     "lang": "en",
 8 |     "maintenanceMessage": "",
 9 | 
10 |     "oidc": {
11 |       "client_id": "topomojo-ui",
12 |       "authority": "https://id.foundry.local",
13 |       "redirect_uri": "https://topomojo.foundry.local/oidc",
14 |       "silent_redirect_uri": "http://topomojo.foundry.local/oidc-silent",
15 |       "post_logout_redirect_uri": "http://topomojo.foundry.local",
16 |       "response_type": "code",
17 |       "scope": "openid profile topomojo-api",
18 |       "automaticSilentRenew": false,
19 |       "includeIdTokenInSilentRenew": false,
20 |       "filterProtocolClaims": true,
21 |       "loadUserInfo": true,
22 |       "accessTokenExpiringNotificationTime": 120,
23 |       "monitorSession": false
24 |     },
25 | 
26 |     "urls": {
27 |       "apiUrl": "https://topomojo.foundry.local",
28 |       "docUrl": "https://topomojo.foundry.local"
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Abstractions/Models/User.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | namespace TopoMojo.Models
 5 | {
 6 |     public class User
 7 |     {
 8 |         public int Id { get; set; }
 9 |         public string GlobalId { get; set; }
10 |         public string Name { get; set; }
11 |         public UserRole Role { get; set; }
12 |         public int WorkspaceLimit { get; set; }
13 |         public string WhenCreated { get; set; }
14 |         public bool IsAdmin => Role == UserRole.Administrator;
15 |         public bool IsCreator => Role == UserRole.Creator || Role == UserRole.Administrator;
16 |     }
17 | 
18 |     public class ChangedUser
19 |     {
20 |         public string GlobalId { get; set; }
21 |         public string Name { get; set; }
22 |     }
23 | 
24 | 
25 |     public enum UserRole
26 |     {
27 |         User,
28 |         Builder,
29 |         Creator,
30 |         Administrator
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Core/Exceptions.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System;
 5 | 
 6 | namespace TopoMojo
 7 | {
 8 |     public class GamespaceLimitReachedException : Exception { }
 9 |     public class WorkspaceLimitReachedException : Exception { }
10 |     public class TemplateLimitReachedException : Exception { }
11 |     public class ParentTemplateException : Exception { }
12 |     public class WorkspaceNotIsolatedException : Exception { }
13 |     public class ActionForbiddenException: Exception { }
14 |     public class InvalidClientAudience: Exception { }
15 |     public class ResourceNotFound: Exception { }
16 |     public class GamespaceNotRegistered: Exception {
17 |         public GamespaceNotRegistered() : base() { }
18 |         public GamespaceNotRegistered(string message) : base(message) { }
19 |         public GamespaceNotRegistered(string message, Exception ex) : base(message, ex) { }
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/Options/AuthorizationOptions.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | namespace TopoMojo.Web
 5 | {
 6 |     public class AuthorizationOptions
 7 |     {
 8 |         public string Authority { get; set; }
 9 |         public string Audience { get; set; } = "topomojo-api";
10 |         public bool RequireHttpsMetadata { get; set; } = true;
11 |         public OAuth2Client SwaggerClient { get; set; }
12 |     }
13 | 
14 |     public class OpenIdClient
15 |     {
16 |         public string ClientId { get; set; }
17 |         public string ClientName { get; set; }
18 |         public string ClientSecret { get; set; }
19 | 
20 |     }
21 | 
22 |     public class OAuth2Client
23 |     {
24 |         public string AuthorizationUrl { get; set; }
25 |         public string TokenUrl { get; set; }
26 |         public string ClientId { get; set; }
27 |         public string ClientName { get; set; }
28 |         public string ClientSecret { get; set; }
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/Options/BrandingOptions.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University.
 2 | // Released under a MIT (SEI) license. See LICENSE.md in the project root.
 3 | 
 4 | namespace TopoMojo.Web
 5 | {
 6 |     public class BrandingOptions
 7 |     {
 8 |         public string ApplicationName { get; set; } = "TopoMojo";
 9 |         public string LogoUrl { get; set; }
10 |         public string Title { get; set; } = "TopoMojo";
11 |         public string[] Meta { get; set; } = new string[] {
12 |             @"<meta name=""description"" content=""Serving #title virtual lab exercise and simulation"">",
13 |             @"<meta property=""og:type"" content=""website"">",
14 |             @"<meta property=""og:title"" content=""#app | #title"">",
15 |             @"<meta property=""og:url"" content=""#url"">",
16 |             @"<meta property=""og:image"" content=""#logo"">",
17 |             @"<meta property=""og:description"" content=""Serving #title virtual lab exercise and simulation"">"
18 |         };
19 | 
20 |         public bool IncludeSwagger { get; set; } = true;
21 |         public string PathBase { get; set; }
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/Extensions/IdentityResolverStartupExtensions.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using Microsoft.AspNetCore.Authentication;
 5 | using Microsoft.AspNetCore.Http;
 6 | using Microsoft.Extensions.Configuration;
 7 | using Microsoft.Extensions.DependencyInjection;
 8 | using Microsoft.Extensions.Options;
 9 | using TopoMojo.Web.Services;
10 | 
11 | namespace TopoMojo.Web.Extensions
12 | {
13 |     public static class DependencyInjectionExtensions
14 |     {
15 | 
16 |         public static IServiceCollection AddIdentityResolver(
17 |             this IServiceCollection services
18 |         ) {
19 |             return services
20 |                 .AddScoped<IdentityResolver>()
21 |                 .AddScoped<Abstractions.IIdentityResolver>(sp => sp.GetService<Services.IdentityResolver>())
22 |                 .AddScoped<IClaimsTransformation>(sp => sp.GetService<Services.IdentityResolver>())
23 |                 .AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
24 |         }
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Core/Data/Entities/Template.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using TopoMojo.Data.Abstractions;
 5 | 
 6 | namespace TopoMojo.Data
 7 | {
 8 |     public class Template : IEntity
 9 |     {
10 |         public int Id { get; set; }
11 |         public string GlobalId { get; set; }
12 |         public string Name { get; set; }
13 |         public System.DateTime WhenCreated { get; set; }
14 |         public string Description { get; set; }
15 |         public string Iso { get; set; }
16 |         public string Networks { get; set; }
17 |         public string Guestinfo { get; set; }
18 |         public bool IsHidden { get; set; }
19 |         public bool IsPublished { get; set; }
20 |         public string Detail { get; set; }
21 |         public int? ParentId { get; set; }
22 |         public int Replicas { get; set; }
23 |         public virtual Template Parent { get; set; }
24 |         public int? WorkspaceId { get; set; }
25 |         public virtual Workspace Workspace { get; set; }
26 | 
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/TopoMojo.vSphere/INetworkManager.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System.Threading.Tasks;
 5 | using NetVimClient;
 6 | using TopoMojo.Models;
 7 | using TopoMojo.vSphere.Helpers;
 8 | 
 9 | namespace TopoMojo.vSphere
10 | {
11 |     public interface INetworkManager
12 |     {
13 |         //props: vim, pool, net, dvs, dvsuuid
14 | 
15 |         Task AddSwitch(string sw);
16 |         Task RemoveSwitch(string sw);
17 |         Task<PortGroupAllocation> AddPortGroup(string sw, VmNet eth);
18 |         Task RemovePortgroup(string pgReference);
19 |         Task<VmNetwork[]> GetVmNetworks(ManagedObjectReference managedObjectReference);
20 |         Task<PortGroupAllocation[]> LoadPortGroups();
21 |         void UpdateEthernetCardBacking(VirtualEthernetCard card, string portgroupName);
22 | 
23 |         Task Initialize();
24 |         Task Provision(VmTemplate template);
25 |         Task Unprovision(ManagedObjectReference vmMOR);
26 |         Task Clean(string tag);
27 |         Task Clean();
28 |         string Resolve(string net);
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/test/TopoMojo.Core.Tests/TopoMojo.Core.Tests.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk">
 2 |   <PropertyGroup>
 3 |     <TargetFramework>netcoreapp3.1</TargetFramework>
 4 |     <DebugType>portable</DebugType>
 5 |     <AssemblyName>TopoMojo.Core.Tests</AssemblyName>
 6 |     <PackageId>TopoMojo.Core.Tests</PackageId>
 7 |     <GenerateRuntimeConfigurationFiles>true</GenerateRuntimeConfigurationFiles>
 8 |   </PropertyGroup>
 9 |   <ItemGroup>
10 |     <ProjectReference Include="../../src/TopoMojo.Abstractions/TopoMojo.Abstractions.csproj" />
11 |     <ProjectReference Include="../../src/TopoMojo.Core/TopoMojo.Core.csproj" />
12 |   </ItemGroup>
13 |   <ItemGroup>
14 |     <FrameworkReference Include="Microsoft.AspNetCore.App" />
15 |     <PackageReference Include="AutoMapper" Version="9.0.0" />
16 |     <PackageReference Include="Microsoft.EntityFrameworkCore" Version="3.1.4" />
17 |     <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="3.1.4" />
18 |     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.0.1" />
19 |     <PackageReference Include="xunit" Version="2.4.1" />
20 |     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1" />
21 |   </ItemGroup>
22 | </Project>
23 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Core/Services/Mappers/TemplateProfile.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System.Linq;
 5 | using AutoMapper;
 6 | using TopoMojo.Data.Extensions;
 7 | using TopoMojo.Models;
 8 | 
 9 | namespace TopoMojo.Services
10 | {
11 |     public class TemplateProfile : Profile
12 |     {
13 |         public TemplateProfile()
14 |         {
15 | 
16 |             CreateMap<Data.Template, TemplateDetail>().ReverseMap();
17 | 
18 |             CreateMap<Data.Template, TemplateSummary>();
19 | 
20 |             CreateMap<Data.Template, Template>()
21 | 
22 |                 .ForMember(d => d.CanEdit, opt =>
23 |                     opt.MapFrom((s, d, m, r) => s.Workspace.CanEdit(r.GetActor())))
24 | 
25 |                 .ReverseMap()
26 |             ;
27 | 
28 |             CreateMap<NewTemplateDetail, Data.Template>();
29 | 
30 |             CreateMap<ChangedTemplate, Data.Template>();
31 | 
32 |             CreateMap<Data.Template, ConvergedTemplate>()
33 |                 .ForMember(d => d.Detail, opt => opt.MapFrom(s => s.Detail ?? s.Parent.Detail))
34 |             ;
35 | 
36 |         }
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/docs/appliance/vols/nginx/conf.d/topomojo.conf:
--------------------------------------------------------------------------------
 1 | server {
 2 |     server_name  topomojo.*;
 3 |     listen       443 ssl http2;
 4 |     listen       [::]:443 ssl http2;
 5 | 
 6 |     set $topomojo_backend http://topomojo;
 7 |     set $topomojo_ui http://topomojo-ui;
 8 | 
 9 |     location /file/upload {
10 |         proxy_request_buffering off;
11 |         proxy_http_version 1.1;
12 |         proxy_pass $topomojo_backend;
13 |         proxy_set_header Host $host;
14 |     }
15 | 
16 |     location /hub {
17 |         proxy_pass $topomojo_backend$request_uri;
18 |         proxy_http_version 1.1;
19 |         proxy_set_header Upgrade $http_upgrade;
20 |         proxy_set_header Connection "upgrade";
21 |         proxy_read_timeout 86400s;
22 |         proxy_send_timeout 86400s;
23 |         proxy_request_buffering off;
24 |         proxy_buffering off;
25 |         proxy_set_header Host $host;
26 |         proxy_ssl_session_reuse on;
27 |     }
28 | 
29 |     location /docs {
30 |         proxy_pass $topomojo_backend;
31 |         proxy_set_header Host $host;
32 |     }
33 | 
34 |     location /api {
35 |         proxy_pass $topomojo_backend;
36 |         proxy_set_header Host $host;
37 |     }
38 | 
39 |     location / {
40 |         proxy_pass $topomojo_ui;
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/Infrastructure/ServiceHostWrapper.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System.Threading;
 5 | using System.Threading.Tasks;
 6 | using Microsoft.Extensions.Hosting;
 7 | 
 8 | namespace TopoMojo.Web.Services
 9 | {
10 |     public class ServiceHostWrapper<T> : IHostedService
11 |         where T : class
12 |     {
13 |         private readonly T backgroundService;
14 | 
15 |         public ServiceHostWrapper(T backgroundService)
16 |         {
17 |             this.backgroundService = backgroundService;
18 |         }
19 | 
20 |         public Task StartAsync(CancellationToken cancellationToken)
21 |         {
22 |             return backgroundService is IHostedService
23 |                 ? ((IHostedService)backgroundService).StartAsync(cancellationToken)
24 |                 : Task.FromResult(0);
25 |         }
26 | 
27 |         public Task StopAsync(CancellationToken cancellationToken)
28 |         {
29 |             return backgroundService is IHostedService
30 |                 ? ((IHostedService)backgroundService).StopAsync(cancellationToken)
31 |                 : Task.FromResult(0);
32 |         }
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/Extensions/TopoMojoStartupExtensions.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. 
 2 | // Released under a MIT (SEI) license. See LICENSE.md in the project root. 
 3 | 
 4 | using System;
 5 | using TopoMojo.Abstractions;
 6 | using TopoMojo.Models;
 7 | using TopoMojo.Web.Services;
 8 | 
 9 | namespace Microsoft.Extensions.DependencyInjection
10 | {
11 |     public static class TopoMojoStartupExtentions
12 |     {
13 |         public static IServiceCollection AddTopoMojoHypervisor(
14 |             this IServiceCollection services,
15 |             Func<HypervisorServiceConfiguration> podConfig
16 |         )
17 |         {
18 |             var config = podConfig();
19 | 
20 |             if (string.IsNullOrWhiteSpace(config.Url))
21 |             {
22 |                 services.AddSingleton<IHypervisorService, TopoMojo.vSphere.MockHypervisorService>();
23 |             }
24 |             else
25 |             {
26 |                 services.AddSingleton<IHypervisorService, TopoMojo.vSphere.HypervisorService>();
27 |             }
28 | 
29 |             services.AddSingleton<HypervisorServiceConfiguration>(sp => config);
30 |             services.AddHostedService<ServiceHostWrapper<IHypervisorService>>();
31 | 
32 |             return services;
33 |         }
34 | 
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/docs/appliance/vols/nginx/conf.d/identity.conf:
--------------------------------------------------------------------------------
 1 | server {
 2 |     server_name  id.*;
 3 |     listen       443 ssl http2;
 4 |     listen       [::]:443 ssl http2;
 5 | 
 6 |     set $id_api http://identity;
 7 |     set $id_ui http://identity-ui;
 8 | 
 9 | #    ssl_verify_client optional;
10 | #    ssl_verify_depth 3;
11 | #    ssl_client_certificate /etc/nginx/conf.d/client-certificate-issuers.pem;
12 |     proxy_set_header Host            $host;
13 |     proxy_set_header X-Forwarded-Host $host;
14 |     proxy_set_header X-Forwarded-Proto $scheme;
15 |     proxy_set_header X-Forwarded-For $remote_addr;
16 | 
17 |     location /ui {
18 |         proxy_pass $id_ui;
19 |     }
20 | 
21 |     location / {
22 |         index /home;
23 |         try_files $uri @proxy;
24 |     }
25 | 
26 |     location @proxy {
27 |         proxy_pass $id_api;
28 |         proxy_set_header Host            $host;
29 |         proxy_set_header X-Forwarded-Host $host;
30 |         proxy_set_header X-Forwarded-Proto $scheme;
31 |         proxy_set_header X-Forwarded-For $remote_addr;
32 |         proxy_set_header ssl-client-subject-dn $ssl_client_s_dn;
33 |         proxy_set_header ssl-client-issuer-dn $ssl_client_i_dn;
34 |         proxy_set_header ssl-client-serial $ssl_client_serial;
35 |         proxy_set_header ssl-client-verify $ssl_client_verify;
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Client/TopoMojo.Client.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk">
 2 | 
 3 |   <PropertyGroup>
 4 |     <TargetFrameworks>netcoreapp3.1;netcoreapp2.1</TargetFrameworks>
 5 |     <Authors>Jeff Mattson</Authors>
 6 |     <Company>Software Engineering Institute</Company>
 7 |     <Copyright>Copyright 2020 Carnegie Mellon University.</Copyright>
 8 |     <PackageId>TopoMojo.Client</PackageId>
 9 |     <PackageLicenseExpression>MIT</PackageLicenseExpression>
10 |     <RepositoryUrl>https://github.com/cmu-sei/TopoMojo</RepositoryUrl>
11 |     <Version>1.3.6</Version>
12 |   </PropertyGroup>
13 | 
14 |   <ItemGroup Condition="'$(TargetFramework)' == 'netcoreapp2.1'">
15 |     <PackageReference Include="Microsoft.AspNetCore.App" />
16 |     <PackageReference Include="Microsoft.Extensions.Http.Polly" Version="2.1" />
17 |     <PackageReference Include="Newtonsoft.Json" Version="12.0.1" />
18 |   </ItemGroup>
19 | 
20 |   <ItemGroup Condition="'$(TargetFramework)' == 'netcoreapp3.1'">
21 |     <FrameworkReference Include="Microsoft.AspNetCore.App" />
22 |     <PackageReference Include="Microsoft.Extensions.Http.Polly" Version="3.1" />
23 |     <PackageReference Include="Newtonsoft.Json" Version="12.0.1" />
24 |   </ItemGroup>
25 | 
26 |   <ItemGroup>
27 |     <ProjectReference Include="..\TopoMojo.Abstractions\TopoMojo.Abstractions.csproj" />
28 |   </ItemGroup>
29 | 
30 | </Project>
31 | 


--------------------------------------------------------------------------------
/docs/appliance/vols/identity-conf/identity-seed.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "Users": [],
 3 |   "ApiResources": [
 4 |     {
 5 |       "Name": "topomojo-api"
 6 |     }
 7 |   ],
 8 |   "Clients": [
 9 |     {
10 |       "Name": "topomojo-swagger",
11 |       "DisplayName": "TopoMojo Swagger",
12 |       "Enabled": true,
13 |       "SeedFlags" : "",
14 |       "SeedGrant": "authorization_code",
15 |       "SeedScopes": "openid topomojo-api",
16 |       "Urls": [
17 |         { "Type": "RedirectUri", "Value": "https://topomojo.foundry.local/api/oauth2-redirect.html" },
18 |         { "Type": "CORSUri", "Value": "https://topomojo.foundry.local" }
19 |       ]
20 |     },
21 |     {
22 |       "Name": "topomojo-ui",
23 |       "DisplayName": "TopoMojo",
24 |       "Enabled": true,
25 |       "SeedFlags" : "Published, RequirePkce",
26 |       "SeedGrant": "authorization_code",
27 |       "SeedScopes": "openid profile topomojo-api",
28 |       "Urls": [
29 |         { "Type": "ClientUri", "Value": "https://topomojo.foundry.local" },
30 |         { "Type": "RedirectUri", "Value": "https://topomojo.foundry.local/oidc" },
31 |         { "Type": "RedirectUri", "Value": "https://topomojo.foundry.local/oidc-silent" },
32 |         { "Type": "PostLogoutRedirectUri", "Value": "https://topomojo.foundry.local" },
33 |         { "Type": "CORSUri", "Value": "https://topomojo.foundry.local" }
34 |       ]
35 |     }
36 |   ]
37 | }
38 | 


--------------------------------------------------------------------------------
/docs/appliance/cfssl/scripts/config.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "signing": {
 3 |         "default": {
 4 |             "expiry": "87600h"
 5 |         },
 6 |         "profiles": {
 7 |             "ca": {
 8 |                 "usages": [
 9 |                     "cert sign"
10 |                 ],
11 |                 "expiry": "87600h"
12 |             },
13 |             "intca": {
14 |                 "usages": [
15 |                     "signing",
16 |                     "key encipherment",
17 |                     "cert sign",
18 |                     "crl sign"
19 |                 ],
20 |                 "expiry": "43800h",
21 |                 "ca_constraint": {
22 |                     "is_ca": true,
23 |                     "max_path_len": 0,
24 |                     "max_path_len_zero": true
25 |                 }
26 |             },
27 |             "client": {
28 |                 "usages": [
29 |                     "signing",
30 |                     "key encipherment",
31 |                     "client auth"
32 |                 ],
33 |                 "expiry": "17520h"
34 |             },
35 |             "server": {
36 |                 "usages": [
37 |                     "signing",
38 |                     "key encipherment",
39 |                     "server auth",
40 |                     "client auth"
41 |                 ],
42 |                 "expiry": "17520h"
43 |             }
44 |         }
45 |     }
46 | }


--------------------------------------------------------------------------------
/src/TopoMojo.Web/Data/Migrations/PostgreSQL/TopoMojoDb/20210206154002_challenge.cs:
--------------------------------------------------------------------------------
 1 | using Microsoft.EntityFrameworkCore.Migrations;
 2 | 
 3 | namespace TopoMojo.Web.Data.Migrations.PostgreSQL.TopoMojoDb
 4 | {
 5 |     public partial class challenge : Migration
 6 |     {
 7 |         protected override void Up(MigrationBuilder migrationBuilder)
 8 |         {
 9 |             migrationBuilder.AddColumn<string>(
10 |                 name: "Challenge",
11 |                 table: "Workspaces",
12 |                 nullable: true);
13 | 
14 |             migrationBuilder.AddColumn<int>(
15 |                 name: "Replicas",
16 |                 table: "Templates",
17 |                 nullable: false,
18 |                 defaultValue: 0);
19 | 
20 |             migrationBuilder.AddColumn<string>(
21 |                 name: "Challenge",
22 |                 table: "Gamespaces",
23 |                 nullable: true);
24 |         }
25 | 
26 |         protected override void Down(MigrationBuilder migrationBuilder)
27 |         {
28 |             migrationBuilder.DropColumn(
29 |                 name: "Challenge",
30 |                 table: "Workspaces");
31 | 
32 |             migrationBuilder.DropColumn(
33 |                 name: "Replicas",
34 |                 table: "Templates");
35 | 
36 |             migrationBuilder.DropColumn(
37 |                 name: "Challenge",
38 |                 table: "Gamespaces");
39 |         }
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/Data/Migrations/SqlServer/TopoMojoDb/20210206153956_challenge.cs:
--------------------------------------------------------------------------------
 1 | using Microsoft.EntityFrameworkCore.Migrations;
 2 | 
 3 | namespace TopoMojo.Web.Data.Migrations.SqlServer.TopoMojoDb
 4 | {
 5 |     public partial class challenge : Migration
 6 |     {
 7 |         protected override void Up(MigrationBuilder migrationBuilder)
 8 |         {
 9 |             migrationBuilder.AddColumn<string>(
10 |                 name: "Challenge",
11 |                 table: "Workspaces",
12 |                 nullable: true);
13 | 
14 |             migrationBuilder.AddColumn<int>(
15 |                 name: "Replicas",
16 |                 table: "Templates",
17 |                 nullable: false,
18 |                 defaultValue: 0);
19 | 
20 |             migrationBuilder.AddColumn<string>(
21 |                 name: "Challenge",
22 |                 table: "Gamespaces",
23 |                 nullable: true);
24 |         }
25 | 
26 |         protected override void Down(MigrationBuilder migrationBuilder)
27 |         {
28 |             migrationBuilder.DropColumn(
29 |                 name: "Challenge",
30 |                 table: "Workspaces");
31 | 
32 |             migrationBuilder.DropColumn(
33 |                 name: "Replicas",
34 |                 table: "Templates");
35 | 
36 |             migrationBuilder.DropColumn(
37 |                 name: "Challenge",
38 |                 table: "Gamespaces");
39 |         }
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/docs/appliance/vols/nginx/nginx.conf:
--------------------------------------------------------------------------------
 1 | 
 2 | user  nginx;
 3 | worker_processes  auto;
 4 | 
 5 | error_log  /var/log/nginx/error.log warn;
 6 | pid        /var/run/nginx.pid;
 7 | 
 8 | 
 9 | events {
10 |     worker_connections  1024;
11 | }
12 | 
13 | 
14 | http {
15 |     include       /etc/nginx/mime.types;
16 |     default_type  application/octet-stream;
17 | 
18 |     log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
19 |                       '$status $body_bytes_sent "$http_referer" '
20 |                       '"$http_user_agent" "$http_x_forwarded_for"';
21 | 
22 |     access_log  /var/log/nginx/access.log  main;
23 | 
24 |     sendfile        on;
25 |     #tcp_nopush     on;
26 | 
27 |     keepalive_timeout  65;
28 | 
29 |     #gzip  on;
30 | 
31 |     resolver 127.0.0.11 ipv6=off valid=30s;
32 | 
33 |     ssl_certificate "/etc/nginx/conf.d/appliance.pem";
34 |     ssl_certificate_key "/etc/nginx/conf.d/appliance-key.pem";
35 |     ssl_session_timeout 1d;
36 |     ssl_session_cache shared:MozSSL:10m;
37 |     ssl_session_tickets off;
38 |     ssl_protocols TLSv1.2 TLSv1.3;
39 |     ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;
40 |     ssl_prefer_server_ciphers off;
41 | 
42 |     root /usr/share/nginx/html;
43 | 
44 |     include /etc/nginx/conf.d/*.conf;
45 | }
46 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Core/Services/Mappers/GamespaceProfile.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using AutoMapper;
 5 | using TopoMojo.Models;
 6 | using TopoMojo.Data.Extensions;
 7 | using TopoMojo.Extensions;
 8 | 
 9 | namespace TopoMojo.Services
10 | {
11 |     public class GamespaceProfile : Profile
12 |     {
13 |         public GamespaceProfile()
14 |         {
15 |             CreateMap<Data.Gamespace, Gamespace>()
16 |                 .ForMember(d => d.WhenCreated, opt => opt.MapFrom(s => s.WhenCreated.ToString("u")))
17 |                 .ForMember(d => d.Slug, opt => opt.MapFrom(s => s.Name.ToSlug()))
18 |             ;
19 | 
20 |             CreateMap<Data.Gamespace, GameState>()
21 |                 .ForMember(d => d.WhenCreated, opt => opt.MapFrom(s => s.WhenCreated.ToString("u")))
22 |                 .ForMember(d => d.Name, opt => opt.MapFrom(s => s.Workspace.Name))
23 |             ;
24 | 
25 |             CreateMap<Data.Player, Player>()
26 |                 .ForMember(d => d.CanManage, opt => opt.MapFrom((s) => s.Permission.CanManage()))
27 |                 .ForMember(d => d.CanEdit, opt => opt.MapFrom((s) => s.Permission.CanEdit()))
28 |             ;
29 | 
30 |             CreateMap<ChallengeSpec, Challenge>();
31 | 
32 |             CreateMap<QuestionSpec, Question>()
33 |                 .ForMember(d => d.Answer, opt => opt.Ignore())
34 |             ;
35 |         }
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/docs/appliance/scripts/install-docker.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | #
 3 | # CENTOS docker install
 4 | #
 5 | 
 6 | # if behind a proxy, set these values first!
 7 | proxy=$1
 8 | noproxy=${2:-localhost,.local}
 9 | 
10 | export http_proxy=$proxy
11 | export https_proxy=$proxy
12 | export noproxy=$noproxy
13 | 
14 | # if [ -n "$proxy" ]; then echo proxy=$proxy >> /etc/yum.conf; fi
15 | 
16 | yum install -y yum-utils
17 | 
18 | yum-config-manager \
19 |     --add-repo \
20 |     https://download.docker.com/linux/centos/docker-ce.repo
21 | 
22 | yum -y install docker-ce docker-ce-cli containerd.io
23 | 
24 | if [ -n "$proxy" ]; then
25 | 
26 |   mkdir -p /etc/systemd/system/docker.service.d
27 |   cat <<EOF >> /etc/systemd/system/docker.service.d/http-proxy.conf
28 | [Service]
29 | Environment="HTTP_PROXY=$proxy"
30 | Environment="HTTPS_PROXY=$proxy"
31 | Environment="NO_PROXY=$noproxy"
32 | EOF
33 | 
34 | fi
35 | 
36 | mkdir -p /etc/docker
37 | cat <<EOF >> /etc/docker/daemon.json
38 | {
39 |   "log-driver": "json-file",
40 |   "log-opts": {
41 |     "max-size": "10m"
42 |   }
43 | }
44 | EOF
45 | 
46 | groupadd docker
47 | usermod -aG docker admin
48 | 
49 | systemctl enable docker
50 | systemctl start docker
51 | 
52 | # install compose
53 | tag=`curl -s https://github.com/docker/compose/releases/latest | awk -F'"' '{print $2}' | awk -F/ '{print $NF}'`
54 | curl -L https://github.com/docker/compose/releases/download/$tag/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
55 | chmod +x /usr/local/bin/docker-compose
56 | 
57 | echo Done installing docker.
58 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/Infrastructure/DisableFormValueModelBindingFilter.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System;
 5 | using System.Linq;
 6 | using Microsoft.AspNetCore.Mvc.Filters;
 7 | using Microsoft.AspNetCore.Mvc.ModelBinding;
 8 | 
 9 | namespace TopoMojo.Web
10 | {
11 | 
12 |     [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
13 |     public class DisableFormValueModelBindingAttribute : Attribute, IResourceFilter
14 |     {
15 |         public void OnResourceExecuting(ResourceExecutingContext context)
16 |         {
17 |             var formValueProviderFactory = context.ValueProviderFactories
18 |                 .OfType<FormValueProviderFactory>()
19 |                 .FirstOrDefault();
20 |             if (formValueProviderFactory != null)
21 |             {
22 |                 context.ValueProviderFactories.Remove(formValueProviderFactory);
23 |             }
24 | 
25 |             var jqueryFormValueProviderFactory = context.ValueProviderFactories
26 |                 .OfType<JQueryFormValueProviderFactory>()
27 |                 .FirstOrDefault();
28 |             if (jqueryFormValueProviderFactory != null)
29 |             {
30 |                 context.ValueProviderFactories.Remove(jqueryFormValueProviderFactory);
31 |             }
32 |         }
33 | 
34 |         public void OnResourceExecuted(ResourceExecutedContext context)
35 |         {
36 |         }
37 |     }
38 | 
39 | }
40 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Core/Services/IdentityService.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System.Threading.Tasks;
 5 | using AutoMapper;
 6 | using TopoMojo.Data.Abstractions;
 7 | using TopoMojo.Models;
 8 | 
 9 | namespace TopoMojo.Services
10 | {
11 |     public class IdentityService
12 |     {
13 |         public IdentityService
14 |         (
15 |             IMapper mapper,
16 |             IUserStore userStore
17 |         )
18 |         {
19 |             _userStore = userStore;
20 |             Mapper = mapper;
21 |         }
22 | 
23 |         IMapper Mapper { get; }
24 |         private readonly IUserStore _userStore;
25 | 
26 |         public async Task<User> Load(string globalId)
27 |         {
28 |             var profile = await _userStore.Load(globalId);
29 | 
30 |             return (profile != null)
31 |                 ? Mapper.Map<User>(profile)
32 |                 : null;
33 |         }
34 | 
35 |         public async Task<User> Add(User profile)
36 |         {
37 |             var entity = await _userStore.Add(
38 |                 Mapper.Map<Data.User>(profile)
39 |             );
40 | 
41 |             return Mapper.Map<User>(entity);
42 |         }
43 | 
44 |         public async Task Update(User profile)
45 |         {
46 |             var entity = await _userStore.Load(profile.Id);
47 | 
48 |             Mapper.Map(profile, entity);
49 | 
50 |             await _userStore.Update(entity);
51 |         }
52 | 
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/Infrastructure/RequestFormLimitsFilter.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System;
 5 | using Microsoft.AspNetCore.Http.Features;
 6 | using Microsoft.AspNetCore.Mvc.Filters;
 7 | 
 8 | namespace TopoMojo.Web
 9 | {
10 |     /// <summary>
11 |     /// Filter to set size limits for request form data
12 |     /// </summary>
13 |     [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
14 |     public class FileUploadMaxSizeAttribute : Attribute, IAuthorizationFilter, IOrderedFilter
15 |     {
16 |         private readonly FormOptions _formOptions;
17 | 
18 |         public FileUploadMaxSizeAttribute(long maxSize)
19 |         {
20 |             _formOptions = new FormOptions()
21 |             {
22 |                 MultipartBodyLengthLimit = maxSize
23 |             };
24 |         }
25 | 
26 |         public int Order { get; set; }
27 | 
28 |         public void OnAuthorization(AuthorizationFilterContext context)
29 |         {
30 |             var features = context.HttpContext.Features;
31 |             var formFeature = features.Get<IFormFeature>();
32 | 
33 |             if (formFeature == null || formFeature.Form == null)
34 |             {
35 |                 // Request form has not been read yet, so set the limits
36 |                 features.Set<IFormFeature>(new FormFeature(context.HttpContext.Request, _formOptions));
37 |             }
38 |         }
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/Readme.md:
--------------------------------------------------------------------------------
 1 | *** 
 2 | *** This application has been transition to a fresh repo.  It will be archived after 
 3 | *** a transition period to v2.0.0 (which is in the "TopoMojo" repo).
 4 | *** 
 5 | 
 6 | # TopoMojo
 7 | 
 8 | A virtual lab builder and player
 9 | 
10 | ## Overview
11 | TopoMojo is an ASP.NET CORE application for creating training content,
12 | or "Labs", and publishing those labs so others can consume them.
13 | 
14 | "Topo" is short for "topology", as in a network topology of
15 | computer hosts.  "Mojo" is the magic of deploying and accessing
16 | those resources on demand.
17 | 
18 | Great for use in a classroom or training environment where hands-
19 | on skill building is desired.
20 | 
21 | Goals:
22 | * Abstract the infrastructure concerns from content producers.
23 | * One-click access for content consumers.
24 | 
25 | ## Getting Started
26 | 
27 | Build with Docker, or:
28 | 1. Install .Net Core SDK 3.1
29 | 2. `dotnet run`
30 | 3. Browse to `http://localhost:5000/api`
31 | 
32 | *NOTE*: The separate `topomojo-ui` repository holds the user interface
33 | for this api.
34 | 
35 | By default, TopoMojo starts with a "Mock" hypervisor manager so you
36 | can investigate it without having to connect it to your hypervisors.
37 | When ready for that you'll need to edit the "Pod" fields in `appsettings.conf`, (or rather in an `appsettings.Development.conf`
38 | copy of it.)
39 | 
40 | *TODO:* More info
41 | 
42 | It also starts with an in-memory database; not usable for production,
43 | but nice for quick startup.  Use the appsettings file to switch to
44 | PostgreSQL or SqlServer.
45 | 
46 | ## Roadmap
47 | * Add Administrator documentation
48 | * Support oVirt/kvm hypervisor
49 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Core/CoreOptions.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | namespace TopoMojo
 5 | {
 6 |     public class CoreOptions
 7 |     {
 8 |         public int GamespaceLimit { get; set; } = 2;
 9 |         public int DefaultWorkspaceLimit { get; set; } = 0;
10 |         public int DefaultTemplateLimit { get; set; } = 3;
11 |         public int NetworkHostTemplateId { get; set; } = 421;
12 |         public int ReplicaLimit { get; set; } = 5;
13 |         public bool AllowUnprivilegedVmReconfigure { get; set; }
14 |         public string GameEngineIsoFolder { get; set; } = "static";
15 |         public string ConsoleHost { get; set; }
16 |         public string DemoCode { get; set; }
17 |         public string LaunchUrl { get; set; } = "/lp/?t=";
18 |         public JanitorOptions Expirations { get; set; } = new JanitorOptions();
19 | 
20 |     }
21 | 
22 |     public class JanitorOptions
23 |     {
24 |         public bool DryRun { get; set; } = true;
25 | 
26 |         // gamespace vm's deleted 12 hours after last activity
27 |         public string IdleGamespaceExpiration { get; set; } = "12h";
28 | 
29 |         // workspace vm's deleted 12 hours after last activity
30 |         public string IdleWorkspaceVmsExpiration { get; set; } = "1d";
31 | 
32 |         // published workspaces deleted 1y after no launches
33 |         public string InactiveWorkspaceExpiration { get; set; } = "1y";
34 | 
35 |         // unpublished workspaces deleted 7d after last activity
36 |         public string UnpublishedWorkspaceTimeout { get; set; } = "1w";
37 |     }
38 | 
39 | }
40 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Core/Extensions/TemplateExtensions.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. 
 2 | // Released under a MIT (SEI) license. See LICENSE.md in the project root. 
 3 | 
 4 | using System;
 5 | using System.Collections.Generic;
 6 | using System.Text.Json;
 7 | using TopoMojo.Extensions;
 8 | using TopoMojo.Models;
 9 | using TopoMojo.Services;
10 | 
11 | namespace TopoMojo
12 | {
13 |     public static class TemplateExtensions
14 |     {
15 |         public static VmTemplate ToVirtualTemplate(this ConvergedTemplate template, string isolationTag = "")
16 |         {
17 |             TemplateUtility tu = new TemplateUtility(template.Detail);
18 |             tu.Name = template.Name;
19 |             tu.Networks = template.Networks ?? "lan";
20 |             tu.Iso = template.Iso;
21 |             tu.IsolationTag = isolationTag.HasValue() ? isolationTag : template.WorkspaceGlobalId ?? Guid.Empty.ToString();
22 |             tu.Id = template.Id.ToString();
23 |             tu.UseUplinkSwitch = template.WorkspaceUseUplinkSwitch;
24 |             tu.AddGuestSettings(template.Guestinfo ?? "");
25 |             return tu.AsTemplate();
26 |         }
27 | 
28 |         // public static void AddSettings(this ConvergedTemplate template, KeyValuePair<string,string>[] settings)
29 |         // {
30 |         //     TemplateUtility tu = new TemplateUtility(template.Detail);
31 |         //     tu.GuestSettings = settings;
32 |         //     template.Detail = tu.ToString();
33 |         // }
34 | 
35 |         public static T Clone<T>(this T obj)
36 |         {
37 |             return JsonSerializer.Deserialize<T>(
38 |                 JsonSerializer.Serialize(obj, null)
39 |             );
40 |         }
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Client/StartupExtensions.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University.
 2 | // Released under a MIT (SEI) license. See LICENSE.md in the project root.
 3 | 
 4 | using System;
 5 | using Polly;
 6 | using Polly.Extensions.Http;
 7 | using TopoMojo.Abstractions;
 8 | using TopoMojo.Client;
 9 | 
10 | namespace Microsoft.Extensions.DependencyInjection
11 | {
12 |     public static class StartupExtensions
13 |     {
14 |         public static IServiceCollection AddTopoMojoClient(
15 |             this IServiceCollection services,
16 |             Func<TopoMojo.Client.Options> config
17 |         )
18 |         {
19 |             var options = config.Invoke();
20 | 
21 |             if (Uri.TryCreate(options.Url, UriKind.Absolute, out Uri uri))
22 |             {
23 |                 // services.AddScoped<ITopoMojoClient, TopoMojoClient>();
24 | 
25 |                 services.AddHttpClient<ITopoMojoClient, TopoMojoClient>()
26 |                 .ConfigureHttpClient(client =>
27 |                 {
28 |                     client.BaseAddress = uri;
29 |                     client.DefaultRequestHeaders.Add("x-api-key", options.Key);
30 |                 })
31 |                 .AddPolicyHandler(
32 |                     HttpPolicyExtensions.HandleTransientHttpError()
33 |                     .OrResult(msg => msg.StatusCode == System.Net.HttpStatusCode.NotFound)
34 |                     .WaitAndRetryAsync(options.MaxRetries, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)))
35 |                 );
36 |             }
37 |             else
38 |             {
39 |                 services.AddScoped<ITopoMojoClient, TopoMojoStub>();
40 |             }
41 | 
42 |             return services;
43 |         }
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/Extensions/CorsExtensions.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using Microsoft.AspNetCore.Cors.Infrastructure;
 5 | using Microsoft.Extensions.Configuration;
 6 | using TopoMojo.Extensions;
 7 | 
 8 | namespace TopoMojo.Web.Extensions
 9 | {
10 |     public static class CorsPolicyExtensions
11 |     {
12 |         public static CorsOptions UseConfiguredCors(
13 |             this CorsOptions builder,
14 |             IConfiguration section
15 |         )
16 |         {
17 |             CorsPolicyOptions policy = section?.Get<CorsPolicyOptions>() ?? new CorsPolicyOptions();
18 |             builder.AddPolicy("default", policy.Build());
19 |             return builder;
20 |         }
21 |     }
22 | 
23 |     public class CorsPolicyOptions
24 |     {
25 |         public string[] Origins { get; set; } = new string[]{};
26 |         public string[] Methods { get; set; } = new string[]{};
27 |         public string[] Headers { get; set; } = new string[]{};
28 |         public bool AllowCredentials { get; set; } = true;
29 | 
30 |         public CorsPolicy Build()
31 |         {
32 |             CorsPolicyBuilder policy = new CorsPolicyBuilder();
33 |             if (Origins.IsEmpty()) policy.AllowAnyOrigin(); else policy.WithOrigins(Origins);
34 |             if (Methods.IsEmpty()) policy.AllowAnyMethod(); else policy.WithMethods(Origins);
35 |             if (Headers.IsEmpty()) policy.AllowAnyHeader(); else policy.WithHeaders(Origins);
36 |             if (AllowCredentials) policy.AllowCredentials(); else policy.DisallowCredentials();
37 |             return policy.Build();
38 |         }
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/Infrastructure/TextMediaTypeFormatter.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System;
 5 | using System.IO;
 6 | using System.Reflection;
 7 | using System.Threading.Tasks;
 8 | using Microsoft.AspNetCore.Mvc.Formatters;
 9 | 
10 | namespace TopoMojo.Web
11 | {
12 |     public class TextMediaTypeFormatter : IInputFormatter
13 |     {
14 |         public bool CanRead(InputFormatterContext context)
15 |         {
16 |             if (context == null) throw new ArgumentNullException(nameof(context));
17 | 
18 |             var contentType = context.HttpContext.Request.ContentType;
19 |             if (contentType == null || contentType == "text/plain")
20 |                 return true;
21 |             return false;
22 |         }
23 | 
24 |         public Task<InputFormatterResult> ReadAsync(InputFormatterContext context)
25 |         {
26 |             if (context == null) throw new ArgumentNullException(nameof(context));
27 | 
28 |             var request = context.HttpContext.Request;
29 |             if (request.ContentLength == 0)
30 |             {
31 |                 if (context.ModelType.GetTypeInfo().IsValueType)
32 |                     return InputFormatterResult.SuccessAsync(Activator.CreateInstance(context.ModelType));
33 |                 else return InputFormatterResult.SuccessAsync(null);
34 |             }
35 | 
36 |             using (var reader = new StreamReader(context.HttpContext.Request.Body))
37 |             {
38 |                 var model = reader.ReadToEndAsync().Result;
39 |                 return InputFormatterResult.SuccessAsync(model);
40 |             }
41 |         }
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Abstractions/Interfaces/IHypervisorService.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System.Collections.Generic;
 5 | using System.Threading.Tasks;
 6 | using TopoMojo.Models;
 7 | 
 8 | namespace TopoMojo.Abstractions
 9 | {
10 |     public interface IHypervisorService
11 |     {
12 |         Task<Vm> Load(string id);
13 |         Task<Vm> Start(string id);
14 |         Task<Vm> Stop(string id);
15 |         Task<Vm> Save(string id);
16 |         Task<Vm> Revert(string id);
17 |         Task<Vm> Delete(string id);
18 |         Task StartAll(string target);
19 |         Task StopAll(string target);
20 |         Task DeleteAll(string target);
21 |         Task<Vm> ChangeState(VmOperation op);
22 |         Task<Vm> ChangeConfiguration(string id, VmKeyValue change);
23 |         Task<Vm> Deploy(VmTemplate template);
24 |         Task SetAffinity(string isolationTag, Vm[] vms, bool start);
25 |         Task<Vm> Refresh(VmTemplate template);
26 |         Task<Vm[]> Find(string searchText);
27 |         Task<int> CreateDisks(VmTemplate template);
28 |         Task<int> VerifyDisks(VmTemplate template);
29 |         Task<int> DeleteDisks(VmTemplate template);
30 |         Task<ConsoleSummary> Display(string id);
31 |         Task<Vm> Answer(string id, VmAnswer answer);
32 |         // Task<TemplateOptions> GetTemplateOptions(string key);
33 |         Task<VmOptions> GetVmIsoOptions(string key);
34 |         Task<VmOptions> GetVmNetOptions(string key);
35 |         string Version { get; }
36 |         Task ReloadHost(string host);
37 | 
38 |         HypervisorServiceConfiguration Options { get; }
39 |     }
40 | 
41 | }
42 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Core/Data/Entities/Workspace.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System;
 5 | using System.Collections.Generic;
 6 | using System.ComponentModel.DataAnnotations.Schema;
 7 | using TopoMojo.Data.Abstractions;
 8 | 
 9 | namespace TopoMojo.Data
10 | {
11 |     public class Workspace : IEntity
12 |     {
13 |         public int Id { get; set; }
14 |         public string GlobalId { get; set; }
15 |         public string Name { get; set; }
16 |         public DateTime WhenCreated { get; set; }
17 |         public string Description { get; set; }
18 |         public string DocumentUrl { get; set; }
19 |         public string Author { get; set; }
20 |         public string Audience { get; set; }
21 |         public string ShareCode { get; set; }
22 |         public bool IsPublished { get; set; }
23 |         public int TemplateLimit { get; set; }
24 |         public bool UseUplinkSwitch { get; set; }
25 |         public int LaunchCount { get; set; }
26 |         public DateTime LastActivity { get; set; }
27 |         public string Challenge { get; set; }
28 |         public virtual ICollection<Worker> Workers { get; set; } = new List<Worker>();
29 |         public virtual ICollection<Gamespace> Gamespaces { get; set; } = new List<Gamespace>();
30 |         public virtual ICollection<Template> Templates { get; set; } = new List<Template>();
31 | 
32 |         [NotMapped]
33 |         public string Document
34 |         {
35 |             get {
36 |                 return (string.IsNullOrEmpty(this.DocumentUrl))
37 |                         ? "/docs/" + this.GlobalId + ".md"
38 |                         : this.DocumentUrl;
39 |             }
40 |         }
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/Infrastructure/ScheduledTasksService.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. 
 2 | // Released under a MIT (SEI) license. See LICENSE.md in the project root. 
 3 | 
 4 | using System;
 5 | using System.Threading;
 6 | using System.Threading.Tasks;
 7 | using Microsoft.Extensions.DependencyInjection;
 8 | using Microsoft.Extensions.Hosting;
 9 | using Microsoft.Extensions.Logging;
10 | using TopoMojo.Services;
11 | 
12 | namespace TopoMojo.Web.Services
13 | {
14 |     public class ScheduledTasksService : IHostedService
15 |     {
16 |         private Timer _timer;
17 |         private readonly ILogger _logger;
18 |         private readonly IServiceProvider _services;
19 | 
20 |         public ScheduledTasksService(
21 |             IServiceProvider serviceProvider,
22 |             ILogger<ScheduledTasksService> logger
23 |         )
24 |         {
25 |             _services = serviceProvider;
26 |             _logger = logger;
27 |         }
28 | 
29 |         public Task StartAsync(CancellationToken cancellationToken)
30 |         {
31 |             var rand = new Random();
32 | 
33 |             _timer = new Timer(StaleCheck,
34 |                 null,
35 |                 rand.Next(10, 30) * 60 * 1000,
36 |                 rand.Next(50, 70) * 60 * 1000
37 |             );
38 | 
39 |             return Task.CompletedTask;
40 |         }
41 | 
42 |         public Task StopAsync(CancellationToken cancellationToken)
43 |         {
44 |             _timer.Dispose();
45 | 
46 |             return Task.CompletedTask;
47 |         }
48 | 
49 |         private void StaleCheck(object state)
50 |         {
51 |            using (var scope = _services.CreateScope())
52 |            {
53 |                var janitor = scope.ServiceProvider.GetService<JanitorService>();
54 |                janitor.Cleanup().Wait();
55 |            }
56 |         }
57 |     }
58 | }
59 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Abstractions/Models/GamespaceSpec.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University.
 2 | // Released under a MIT (SEI) license. See LICENSE.md in the project root.
 3 | 
 4 | using System;
 5 | 
 6 | namespace TopoMojo.Models
 7 | {
 8 |     public class NewGamespace
 9 |     {
10 |         public string Id { get; set; }
11 |         public GamespaceSpec Workspace { get; set; }
12 |     }
13 | 
14 |     public class GamespaceSpec
15 |     {
16 |         public string IsolationId { get; set; }
17 |         [Obsolete]
18 |         public int WorkspaceId { get; set; }
19 |         public string WorkspaceGuid { get; set; }
20 |         public VmSpec[] Vms { get; set; } = new VmSpec[] {};
21 |         public bool CustomizeTemplates { get; set; }
22 |         public string Templates { get; set; }
23 |         public string Iso { get; set; }
24 |         public string IsoTarget { get; set; }
25 |         public bool HostAffinity { get; set; }
26 |         public bool AppendMarkdown { get; set; }
27 |     }
28 | 
29 |     public class VmSpec
30 |     {
31 |         public string Name { get; set; }
32 |         public int Replicas { get; set; }
33 |         public bool SkipIso { get; set; }
34 |     }
35 | 
36 |     public class NetworkServerSpec
37 |     {
38 |         public string IpAddress { get; set; }
39 |         public string[] Dnsmasq { get; set; } = new string[] {};
40 |         public string[] HostFileEntries { get; set; } = new string[] {};
41 |     }
42 | 
43 |     public class VmAction
44 |     {
45 |         public string Id { get; set; }
46 |         public string IsolationId { get; set; }
47 |         public string Type { get; set; }
48 |         public string Message { get; set; }
49 |     }
50 | 
51 |      public class IsoBuildSpec
52 |     {
53 |         public string Name { get; set; }
54 |         public string Hash { get; set; }
55 |         public string[] Files { get; set; }
56 |     }
57 | 
58 | }
59 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Abstractions/Models/GamespaceModels.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System.Collections.Generic;
 5 | 
 6 | namespace TopoMojo.Models
 7 | {
 8 |     public class Gamespace
 9 |     {
10 |         public int Id { get; set; }
11 |         public string GlobalId { get; set; }
12 |         public string Name { get; set; }
13 |         public string Slug { get; set; }
14 |         public string Audience { get; set; }
15 |         public string WhenCreated { get; set; }
16 |         public string WorkspaceDocument { get; set; }
17 |         public int WorkspaceId { get; set; }
18 |         public Player[] Players { get; set; }
19 |     }
20 | 
21 |     public class GameState
22 |     {
23 |         public int Id { get; set; }
24 |         public string Name { get; set; }
25 |         public string GlobalId { get; set; }
26 |         public string WhenCreated { get; set; }
27 |         public string WorkspaceDocument { get; set; }
28 |         public string Markdown { get; set; }
29 |         public string ShareCode { get; set; }
30 |         public string Audience { get; set; }
31 |         public Player[] Players { get; set; }
32 |         public IEnumerable<VmState> Vms { get; set; } = new List<VmState>();
33 | 
34 |     }
35 | 
36 |     public class VmState
37 |     {
38 |         public string Id { get; set; }
39 |         public int TemplateId { get; set; }
40 |         public string Name { get; set; }
41 |         public bool IsRunning { get; set; }
42 |     }
43 | 
44 |     public class Player
45 |     {
46 |         public int Id { get; set; }
47 |         public int PersonId { get; set; }
48 |         public string PersonName { get; set; }
49 |         public string PersonGlobalId { get; set; }
50 |         public bool CanManage { get; set; }
51 |         public bool CanEdit { get; set; }
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/test/TopoMojo.Core.Tests/StubDistributedCache.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. 
 2 | // Released under a MIT (SEI) license. See LICENSE.md in the project root. 
 3 | 
 4 | using System.Collections.Generic;
 5 | using System.Threading;
 6 | using System.Threading.Tasks;
 7 | using Microsoft.Extensions.Caching.Distributed;
 8 | 
 9 | namespace Tests
10 | {
11 |     public class StubDistributedCache : IDistributedCache
12 |     {
13 |         Dictionary<string, byte[]> _cache = new Dictionary<string, byte[]>();
14 | 
15 |         public byte[] Get(string key)
16 |         {
17 |             return _cache.ContainsKey(key)
18 |                 ? _cache[key]
19 |                 : null;
20 |         }
21 | 
22 |         public Task<byte[]> GetAsync(string key, CancellationToken token = default)
23 |         {
24 |             return Task.FromResult(Get(key));
25 |         }
26 | 
27 |         public void Refresh(string key)
28 |         {
29 | 
30 |         }
31 | 
32 |         public Task RefreshAsync(string key, CancellationToken token = default)
33 |         {
34 |             return Task.FromResult(0);
35 |         }
36 | 
37 |         public void Remove(string key)
38 |         {
39 |             if (_cache.ContainsKey(key))
40 |                 _cache.Remove(key);
41 |         }
42 | 
43 |         public Task RemoveAsync(string key, CancellationToken token = default)
44 |         {
45 |             Remove(key);
46 |             return Task.FromResult(0);
47 |         }
48 | 
49 |         public void Set(string key, byte[] value, DistributedCacheEntryOptions options)
50 |         {
51 |             if (_cache.ContainsKey(key))
52 |                 _cache[key] = value;
53 |             else
54 |                 _cache.Add(key, value);
55 |         }
56 | 
57 |         public Task SetAsync(string key, byte[] value, DistributedCacheEntryOptions options, CancellationToken token = default)
58 |         {
59 |             Set(key, value, options);
60 |             return Task.FromResult(0);
61 |         }
62 |     }
63 | }
64 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/Data/Migrations/SqlServer/TopoMojoDb/20210218013145_ExpandTemplateLimits.cs:
--------------------------------------------------------------------------------
 1 | using Microsoft.EntityFrameworkCore.Migrations;
 2 | 
 3 | namespace TopoMojo.Web.Data.Migrations.SqlServer.TopoMojoDb
 4 | {
 5 |     public partial class ExpandTemplateLimits : Migration
 6 |     {
 7 |         protected override void Up(MigrationBuilder migrationBuilder)
 8 |         {
 9 |             migrationBuilder.AlterColumn<string>(
10 |                 name: "Guestinfo",
11 |                 table: "Templates",
12 |                 maxLength: 1024,
13 |                 nullable: true,
14 |                 oldClrType: typeof(string),
15 |                 oldType: "nvarchar(255)",
16 |                 oldMaxLength: 255,
17 |                 oldNullable: true);
18 | 
19 |             migrationBuilder.AlterColumn<string>(
20 |                 name: "Detail",
21 |                 table: "Templates",
22 |                 maxLength: 4096,
23 |                 nullable: true,
24 |                 oldClrType: typeof(string),
25 |                 oldType: "nvarchar(2048)",
26 |                 oldMaxLength: 2048,
27 |                 oldNullable: true);
28 |         }
29 | 
30 |         protected override void Down(MigrationBuilder migrationBuilder)
31 |         {
32 |             migrationBuilder.AlterColumn<string>(
33 |                 name: "Guestinfo",
34 |                 table: "Templates",
35 |                 type: "nvarchar(255)",
36 |                 maxLength: 255,
37 |                 nullable: true,
38 |                 oldClrType: typeof(string),
39 |                 oldMaxLength: 1024,
40 |                 oldNullable: true);
41 | 
42 |             migrationBuilder.AlterColumn<string>(
43 |                 name: "Detail",
44 |                 table: "Templates",
45 |                 type: "nvarchar(2048)",
46 |                 maxLength: 2048,
47 |                 nullable: true,
48 |                 oldClrType: typeof(string),
49 |                 oldMaxLength: 4096,
50 |                 oldNullable: true);
51 |         }
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/Infrastructure/HeaderInspectionMiddleware.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University.
 2 | // Released under a MIT (SEI) license. See LICENSE.md in the project root.
 3 | 
 4 | using System.Linq;
 5 | using System.Text;
 6 | using System.Threading.Tasks;
 7 | using Microsoft.AspNetCore.Http;
 8 | using Microsoft.Extensions.Logging;
 9 | using TopoMojo.Web;
10 | 
11 | namespace TopoMojo.Web
12 | {
13 |     public class HeaderInspectionMiddleware
14 |     {
15 |         public HeaderInspectionMiddleware(
16 |             RequestDelegate next,
17 |             ILogger<HeaderInspectionMiddleware> logger
18 |         ){
19 |             _next = next;
20 |             _logger = logger;
21 |         }
22 |         private readonly RequestDelegate _next;
23 |         private readonly ILogger _logger;
24 | 
25 |         public async Task Invoke(HttpContext context)
26 |         {
27 |             var sb = new StringBuilder($"Request Headers: {context.Request.Scheme}://{context.Request.Host}{context.Request.PathBase} from {context.Connection.RemoteIpAddress}\n");
28 | 
29 |             sb.AppendLine($"\t{context.Request.Method} {context.Request.Path.Value} {context.Request.Protocol}");
30 | 
31 |             foreach (var header in context.Request.Headers)
32 |             {
33 |                 string val = header.Value;
34 | 
35 |                 if (header.Key.StartsWith("Authorization"))
36 |                     val = header.Value.ToString().Split(' ').First() + " **redacted**";
37 | 
38 |                 sb.AppendLine($"\t{header.Key}: {val}");
39 |             }
40 | 
41 |             _logger.LogInformation(sb.ToString());
42 | 
43 |             await _next(context);
44 |         }
45 |     }
46 | }
47 | 
48 | namespace Microsoft.AspNetCore.Builder
49 | {
50 |     public static class StartUpExtensions
51 |     {
52 |         public static IApplicationBuilder UseHeaderInspection (
53 |             this IApplicationBuilder builder
54 |         )
55 |         {
56 |             return builder.UseMiddleware<HeaderInspectionMiddleware>();
57 |         }
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Abstractions/Models/VmTemplate.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System.Collections.Generic;
 5 | 
 6 | namespace TopoMojo.Models
 7 | {
 8 |     public class VmTemplate
 9 |     {
10 |         public string Id { get; set; }
11 |         public string Name { get; set; }
12 |         public string TopoId { get; set; }
13 |         public string Cpu { get; set; }
14 |         public string Guest { get; set; }
15 |         public string Source { get; set; }
16 |         public string Iso { get; set; }
17 |         public string Floppy { get; set; }
18 |         public string Version { get; set; }
19 |         public string IsolationTag { get; set; }
20 |         public bool UseUplinkSwitch {get; set; }
21 |         public int Ram { get; set; }
22 |         public int VideoRam { get; set; }
23 |         public int Adapters { get; set; }
24 |         public int Delay { get; set; }
25 |         public bool AutoStart { get; set; } = true;
26 |         public VmNet[] Eth { get; set; }
27 |         public VmDisk[] Disks { get; set; }
28 |         public VmKeyValue[] GuestSettings { get; set; }
29 |     }
30 | 
31 |     public class VmNet
32 |     {
33 |         public int Id { get; set; }
34 |         public string Net { get; set; }
35 |         public string Key { get; set; }
36 |         public string Type { get; set; }
37 |         public string Mac { get; set; }
38 |         public string Ip { get; set; }
39 |         public int Vlan { get; set; }
40 |     }
41 | 
42 |     public class VmDisk
43 |     {
44 |         public int Id { get; set; }
45 |         public string Path { get; set; }
46 |         public string Source { get; set; }
47 |         public string Controller { get; set; }
48 |         public int Size { get; set; }
49 |         public int Status { get; set; }
50 |     }
51 | 
52 |     public class VmKeyValue
53 |     {
54 |         public string Key { get; set; }
55 |         public string Value { get; set; }
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/TopoMojo.Web.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk.Web">
 2 |   <PropertyGroup>
 3 |     <TargetFramework>netcoreapp3.1</TargetFramework>
 4 |     <PreserveCompilationContext>true</PreserveCompilationContext>
 5 |   </PropertyGroup>
 6 |   <PropertyGroup>
 7 |     <GenerateDocumentationFile>true</GenerateDocumentationFile>
 8 |     <NoWarn>$(NoWarn);1591</NoWarn>
 9 |   </PropertyGroup>
10 |   <ItemGroup>
11 |     <Content Update="wwwroot/docs/**/*;**/*.json;**/*.DS_Store" CopyToPublishDirectory="Never" />
12 |     <Content Update="appsettings.conf;appsettings.json;seed-data.json.example" CopyToPublishDirectory="Always" />
13 |   </ItemGroup>
14 |   <ItemGroup>
15 |     <ProjectReference Include="..\TopoMojo.Abstractions\TopoMojo.Abstractions.csproj" />
16 |     <ProjectReference Include="..\TopoMojo.Core\TopoMojo.Core.csproj" />
17 |     <ProjectReference Include="..\TopoMojo.vSphere\TopoMojo.vSphere.csproj" />
18 |   </ItemGroup>
19 |   <ItemGroup>
20 |     <PackageReference Include="AutoMapper" Version="9.0.0" />
21 |     <PackageReference Include="DiscUtils.Iso9660" Version="0.14.2-alpha" />
22 |     <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="3.1.4">
23 |       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
24 |       <PrivateAssets>all</PrivateAssets>
25 |     </PackageReference>
26 |     <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="3.1" />
27 |     <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="3.1" />
28 |     <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="3.1.4" />
29 |     <PackageReference Include="Swashbuckle.AspNetCore" Version="5.5" />
30 |     <PackageReference Include="Swashbuckle.AspNetCore.Annotations" Version="5.5" />
31 |     <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="3.1" />
32 |     <PackageReference Include="Microsoft.AspNetCore.DataProtection.StackExchangeRedis" Version="3.1" />
33 |     <PackageReference Include="Microsoft.Extensions.Caching.StackExchangeRedis" Version="3.1" />
34 |   </ItemGroup>
35 | </Project>
36 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Abstractions/Models/Registration.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University.
 2 | // Released under a MIT (SEI) license. See LICENSE.md in the project root.
 3 | 
 4 | using System.Collections.Generic;
 5 | 
 6 | namespace TopoMojo.Models
 7 | {
 8 |     public class Registration
 9 |     {
10 |         public string SubjectId { get; set; }
11 |         public string SubjectName { get; set; }
12 |         public string ResourceId { get; set; }
13 |         public string GamespaceId { get; set; }
14 |         public string ClientId { get; set; }
15 |         public string Token { get; set; }
16 |         public string RedirectUrl { get; set; }
17 |         public Challenge Challenge { get; set; }
18 |     }
19 | 
20 |     public class RegistrationRequest
21 |     {
22 |         public string SubjectId { get; set; }
23 |         public string SubjectName { get; set; }
24 |         public string ResourceId { get; set; }
25 |     }
26 | 
27 |     public class ChallengeSpec
28 |     {
29 |         public ICollection<QuestionSpec> Questions { get; set; } = new List<QuestionSpec>();
30 |         public Dictionary<string,string> Randoms { get; set; } = new Dictionary<string, string>();
31 |     }
32 | 
33 |     public class QuestionSpec
34 |     {
35 |         public string Text { get; set; }
36 |         public string Hint { get; set; }
37 |         public string Answer { get; set; }
38 |         public float Weight { get; set; }
39 |         public AnswerGrader Grader { get; set; }
40 |     }
41 | 
42 |     public class Challenge
43 |     {
44 |         public string GamespaceId { get; set; }
45 |         public ICollection<Question> Questions { get; set; } = new List<Question>();
46 |         public float Score { get; set; }
47 |     }
48 | 
49 |     public class Question
50 |     {
51 |         public string Text { get; set; }
52 |         public string Hint { get; set; }
53 |         public string Answer { get; set; }
54 |         public float Weight { get; set; }
55 |         public bool IsCorrect { get; set; }
56 |     }
57 | 
58 |     public enum AnswerGrader
59 |     {
60 |         Match,
61 |         MatchAll,
62 |         MatchAny
63 |     }
64 | }
65 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Abstractions/Models/HypervisorServiceConfiguration.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System.Collections.Generic;
 5 | 
 6 | namespace TopoMojo.Models
 7 | {
 8 |     public class HypervisorServiceConfiguration {
 9 |         public bool IsVCenter { get; set; }
10 |         public string Type { get; set; }
11 |         public string Url { get; set;}
12 |         public string Host { get; set;}
13 |         public string User { get; set; }
14 |         public string Password { get; set; }
15 |         public string PoolPath { get; set; }
16 |         public string Uplink { get; set; } = "dvs-topomojo";
17 |         public string VmStore { get; set; } = "[topomojo] _run/";
18 |         public string DiskStore { get; set; } = "[topomojo]";
19 |         public string IsoStore { get; set; } = "[topomojo] iso/";
20 |         public string TicketUrlHandler { get; set; }  = "querystring"; //"local-app", "external-domain", "host-map", "none"
21 |         public Dictionary<string,string> TicketUrlHostMap { get; set; } = new Dictionary<string, string>();
22 |         public VlanConfiguration Vlan { get; set; } = new VlanConfiguration();
23 |         public int KeepAliveMinutes { get; set; } = 10;
24 |         public string ExcludeNetworkMask { get; set; } = "topomojo";
25 |         public SddcConfiguration Sddc { get; set; } = new SddcConfiguration();
26 |     }
27 | 
28 |     public class SddcConfiguration
29 |     {
30 |         public string Url { get; set; }
31 |         public string AuthUrl { get; set; }
32 |         public string OrgId { get; set; }
33 |         public string SddcId { get; set; }
34 |         public string ApiKey { get; set; }
35 |     }
36 | 
37 |     public class VlanConfiguration
38 |     {
39 |         public string Range { get; set; }
40 |         public Vlan[] Reservations { get; set; } = new Vlan[] {};
41 |     }
42 | 
43 |     public class Vlan
44 |     {
45 |         public int Id { get; set; }
46 |         public string Name { get; set; }
47 |         public bool OnUplink { get; set; }
48 |     }
49 | 
50 | }
51 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/Extensions/CachingExtensions.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University.
 2 | // Released under a MIT (SEI) license. See LICENSE.md in the project root.
 3 | 
 4 | using System;
 5 | using System.IO;
 6 | using Microsoft.AspNetCore.DataProtection;
 7 | using StackExchange.Redis;
 8 | using TopoMojo.Web;
 9 | 
10 | namespace Microsoft.Extensions.DependencyInjection
11 | {
12 |     public static class CachingExtensions
13 |     {
14 |         public static IServiceCollection AddCache(this IServiceCollection services, Func<CacheOptions> configure = null)
15 |         {
16 |             var options = (configure != null)
17 |                 ? configure()
18 |                 : new CacheOptions();
19 | 
20 |             services.AddMemoryCache();
21 | 
22 |             services.AddSingleton<CacheOptions>(_ => options);
23 | 
24 |             if (System.String.IsNullOrWhiteSpace(options?.RedisUrl))
25 |             {
26 |                 services.AddDistributedMemoryCache();
27 |             }
28 |             else
29 |             {
30 |                 services.AddStackExchangeRedisCache(opt => {
31 |                     opt.Configuration = options.RedisUrl;
32 |                     opt.InstanceName = options.Key;
33 |                 });
34 |             }
35 | 
36 |             return services;
37 |         }
38 | 
39 |         public static IDataProtectionBuilder PersistKeys(this IDataProtectionBuilder builder, Func<CacheOptions> configure = null)
40 |         {
41 |             var options = (configure != null)
42 |                 ? configure()
43 |                 : new CacheOptions();
44 | 
45 |             if (System.String.IsNullOrWhiteSpace(options?.RedisUrl))
46 |             {
47 |                 builder.PersistKeysToFileSystem(
48 |                     new DirectoryInfo(Path.Combine(options.SharedFolder, options.DataProtectionFolder))
49 |                 );
50 |             }
51 |             else
52 |             {
53 |                 builder.PersistKeysToStackExchangeRedis(
54 |                     ConnectionMultiplexer.Connect(options.RedisUrl),
55 |                     $"{options.Key}-dpk"
56 |                 );
57 |             }
58 | 
59 |             return builder;
60 |         }
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Core/Services/_Service.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System;
 5 | using System.Text.Json;
 6 | using System.Text.Json.Serialization;
 7 | using AutoMapper;
 8 | using Microsoft.Extensions.Logging;
 9 | using TopoMojo.Abstractions;
10 | using TopoMojo.Models;
11 | 
12 | namespace TopoMojo.Services
13 | {
14 |     public abstract class _Service
15 |     {
16 |         public _Service(
17 |             ILogger logger,
18 |             IMapper mapper,
19 |             CoreOptions options,
20 |             IIdentityResolver identityResolver
21 |         )
22 |         {
23 |             _logger = logger;
24 |             _options = options;
25 |             _identityResolver = identityResolver;
26 |             Mapper = mapper;
27 | 
28 |             jsonOptions = new JsonSerializerOptions
29 |             {
30 |                 AllowTrailingCommas = true,
31 |                 PropertyNamingPolicy = JsonNamingPolicy.CamelCase
32 |             };
33 |             jsonOptions.Converters.Add(
34 |                 new JsonStringEnumConverter(JsonNamingPolicy.CamelCase)
35 |             );
36 |         }
37 | 
38 |         protected IMapper Mapper { get; }
39 |         protected ILogger _logger { get; }
40 |         protected CoreOptions _options { get; }
41 |         protected JsonSerializerOptions jsonOptions { get; }
42 |         private IIdentityResolver _identityResolver { get; }
43 |         // private Data.Profile _user;
44 |         // protected Data.Profile User
45 |         // {
46 |         //     get
47 |         //     {
48 |         //         if (_user == null)
49 |         //             _user = Mapper.Map<Data.Profile>(_identityResolver.User);
50 |         //         return _user;
51 |         //     }
52 |         // }
53 | 
54 |         protected User User => _identityResolver.User;
55 |         protected Client Client => _identityResolver.Client;
56 | 
57 |         protected Action<IMappingOperationOptions> WithActor()
58 |         {
59 |             return opts => {
60 |                 opts.Items["Actor"] = User;
61 |             };
62 |         }
63 | 
64 |     }
65 | }
66 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/Controllers/_Controller.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System;
 5 | using Microsoft.AspNetCore.Mvc;
 6 | using Microsoft.AspNetCore.Mvc.Filters;
 7 | using Microsoft.Extensions.Logging;
 8 | using Microsoft.Extensions.Options;
 9 | using Microsoft.Extensions.DependencyInjection;
10 | using TopoMojo.Abstractions;
11 | using TopoMojo.Models;
12 | using TopoMojo.Web;
13 | 
14 | namespace TopoMojo.Web.Controllers
15 | {
16 |     public class _Controller : Controller
17 |     {
18 |         public _Controller(
19 |             ILogger logger,
20 |             IIdentityResolver identityResolver
21 |         )
22 |         {
23 |             _logger = logger;
24 |             _identityResolver = identityResolver;
25 |         }
26 | 
27 |         protected User _user;
28 |         protected Client _client;
29 |         protected readonly IIdentityResolver _identityResolver;
30 |         protected readonly ILogger _logger;
31 | 
32 |         public override void OnActionExecuting(ActionExecutingContext context)
33 |         {
34 |             _user = _identityResolver.User;
35 |             _client = _identityResolver.Client;
36 |         }
37 | 
38 |         internal void Log(string action, dynamic item, string msg = "")
39 |         {
40 |             string entry = String.Format("{0} [{1}] {2} {3} {4} [{5}] {6}",
41 |                 _user?.Name, _user?.GlobalId, action, item?.GetType().Name, item?.Name, item?.Id, msg);
42 | 
43 |             _logger.LogInformation(entry);
44 |         }
45 | 
46 |         /// <summary>
47 |         /// Apply PathBase to urls generated in service
48 |         /// </summary>
49 |         /// <param name="target"></param>
50 |         internal string ApplyPathBase(string target)
51 |         {
52 |             if (
53 |                 !string.IsNullOrEmpty(Request.PathBase)
54 |                 && !string.IsNullOrEmpty(target)
55 |                 && !target.Contains("://")
56 |             )
57 |             {
58 |                 return Request.PathBase + target;
59 |             }
60 | 
61 |             return target;
62 |         }
63 |     }
64 | }
65 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Abstractions/Models/Vm.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System;
 5 | 
 6 | namespace TopoMojo.Models
 7 | {
 8 |     public class Vm
 9 |     {
10 |         public string Id { get; set; }
11 |         public string Name { get; set; }
12 |         public string Host { get; set; }
13 |         public string Path { get; set; }
14 |         public string Reference { get; set; }
15 |         public string DiskPath { get; set; }
16 |         public string Stats { get; set; }
17 |         public string Status { get; set; }
18 |         public string GroupName { get; set; }
19 |         public VmPowerState State { get; set; }
20 |         public VmQuestion Question { get; set; }
21 |         public VmTask Task { get; set; }
22 |     }
23 | 
24 |     public enum VmPowerState { Off, Running, Suspended}
25 | 
26 |     public class VmQuestion
27 |     {
28 |         public string Id { get; set; }
29 |         public string Prompt { get; set; }
30 |         public string DefaultChoice { get; set; }
31 |         public VmQuestionChoice[] Choices { get; set; }
32 |     }
33 | 
34 |     public class VmAnswer
35 |     {
36 |         public string QuestionId { get; set; }
37 |         public string ChoiceKey { get; set; }
38 |     }
39 | 
40 |     public class VmQuestionChoice
41 |     {
42 |         public string Key { get; set; }
43 |         public string Label { get; set; }
44 |     }
45 | 
46 |     public class VmTask
47 |     {
48 |         public string Id { get; set; }
49 |         public string Name { get; set; }
50 |         public int Progress { get; set; }
51 |         public DateTime WhenCreated { get; set; }
52 |     }
53 | 
54 |     public class VmOptions {
55 |         public string[] Iso { get; set; }
56 |         public string[] Net { get; set; }
57 |     }
58 | 
59 |      public class VmOperation
60 |     {
61 |         public string Id { get; set; }
62 |         public VmOperationType Type { get; set; }
63 |         public int WorkspaceId { get; set; }
64 |     }
65 | 
66 |     public enum VmOperationType
67 |     {
68 |         Start,
69 |         Stop,
70 |         Save,
71 |         Revert,
72 |         Delete
73 |     }
74 | }
75 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/Data/Migrations/PostgreSQL/TopoMojoDb/20200603185146_Audience.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. 
 2 | // Released under a MIT (SEI) license. See LICENSE.md in the project root. 
 3 | 
 4 | using Microsoft.EntityFrameworkCore.Migrations;
 5 | 
 6 | namespace TopoMojo.Web.Data.Migrations.PostgreSQL.TopoMojoDb
 7 | {
 8 |     public partial class Audience : Migration
 9 |     {
10 |         protected override void Up(MigrationBuilder migrationBuilder)
11 |         {
12 |             migrationBuilder.AlterColumn<string>(
13 |                 name: "DocumentUrl",
14 |                 table: "Workspaces",
15 |                 maxLength: 128,
16 |                 nullable: true,
17 |                 oldClrType: typeof(string),
18 |                 oldType: "text",
19 |                 oldNullable: true);
20 | 
21 |             migrationBuilder.AlterColumn<string>(
22 |                 name: "Guestinfo",
23 |                 table: "Templates",
24 |                 maxLength: 255,
25 |                 nullable: true,
26 |                 oldClrType: typeof(string),
27 |                 oldType: "text",
28 |                 oldNullable: true);
29 | 
30 |             migrationBuilder.AddColumn<string>(
31 |                 name: "Audience",
32 |                 table: "Gamespaces",
33 |                 maxLength: 64,
34 |                 nullable: true);
35 |         }
36 | 
37 |         protected override void Down(MigrationBuilder migrationBuilder)
38 |         {
39 |             migrationBuilder.DropColumn(
40 |                 name: "Audience",
41 |                 table: "Gamespaces");
42 | 
43 |             migrationBuilder.AlterColumn<string>(
44 |                 name: "DocumentUrl",
45 |                 table: "Workspaces",
46 |                 type: "text",
47 |                 nullable: true,
48 |                 oldClrType: typeof(string),
49 |                 oldMaxLength: 128,
50 |                 oldNullable: true);
51 | 
52 |             migrationBuilder.AlterColumn<string>(
53 |                 name: "Guestinfo",
54 |                 table: "Templates",
55 |                 type: "text",
56 |                 nullable: true,
57 |                 oldClrType: typeof(string),
58 |                 oldMaxLength: 255,
59 |                 oldNullable: true);
60 |         }
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/Data/Migrations/SqlServer/TopoMojoDb/20200603185140_Audience.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. 
 2 | // Released under a MIT (SEI) license. See LICENSE.md in the project root. 
 3 | 
 4 | using Microsoft.EntityFrameworkCore.Migrations;
 5 | 
 6 | namespace TopoMojo.Web.Data.Migrations.SqlServer.TopoMojoDb
 7 | {
 8 |     public partial class Audience : Migration
 9 |     {
10 |         protected override void Up(MigrationBuilder migrationBuilder)
11 |         {
12 |             migrationBuilder.AlterColumn<string>(
13 |                 name: "DocumentUrl",
14 |                 table: "Workspaces",
15 |                 maxLength: 128,
16 |                 nullable: true,
17 |                 oldClrType: typeof(string),
18 |                 oldType: "nvarchar(max)",
19 |                 oldNullable: true);
20 | 
21 |             migrationBuilder.AlterColumn<string>(
22 |                 name: "Guestinfo",
23 |                 table: "Templates",
24 |                 maxLength: 255,
25 |                 nullable: true,
26 |                 oldClrType: typeof(string),
27 |                 oldType: "nvarchar(max)",
28 |                 oldNullable: true);
29 | 
30 |             migrationBuilder.AddColumn<string>(
31 |                 name: "Audience",
32 |                 table: "Gamespaces",
33 |                 maxLength: 64,
34 |                 nullable: true);
35 |         }
36 | 
37 |         protected override void Down(MigrationBuilder migrationBuilder)
38 |         {
39 |             migrationBuilder.DropColumn(
40 |                 name: "Audience",
41 |                 table: "Gamespaces");
42 | 
43 |             migrationBuilder.AlterColumn<string>(
44 |                 name: "DocumentUrl",
45 |                 table: "Workspaces",
46 |                 type: "nvarchar(max)",
47 |                 nullable: true,
48 |                 oldClrType: typeof(string),
49 |                 oldMaxLength: 128,
50 |                 oldNullable: true);
51 | 
52 |             migrationBuilder.AlterColumn<string>(
53 |                 name: "Guestinfo",
54 |                 table: "Templates",
55 |                 type: "nvarchar(max)",
56 |                 nullable: true,
57 |                 oldClrType: typeof(string),
58 |                 oldMaxLength: 255,
59 |                 oldNullable: true);
60 |         }
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/Options/HeaderOptions.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University.
 2 | // Released under a MIT (SEI) license. See LICENSE.md in the project root.
 3 | 
 4 | using Microsoft.AspNetCore.Cors.Infrastructure;
 5 | 
 6 | namespace TopoMojo.Web
 7 | {
 8 |     public class HeaderOptions
 9 |     {
10 |         public bool LogHeaders { get; set; }
11 |         public bool UseHsts { get; set; }
12 |         public CorsPolicyOptions Cors { get; set; } = new CorsPolicyOptions();
13 |         public SecurityHeaderOptions Security { get; set; } = new SecurityHeaderOptions();
14 |         public ForwardHeaderOptions Forwarding { get; set; } = new ForwardHeaderOptions();
15 |     }
16 | 
17 |     public class ForwardHeaderOptions
18 |     {
19 |         public int ForwardLimit { get; set; } = 1;
20 |         public string KnownProxies { get; set; }
21 |         public string KnownNetworks { get; set; }
22 |         public string TargetHeaders { get; set; }
23 |     }
24 | 
25 |     public class SecurityHeaderOptions
26 |     {
27 |         public string ContentSecurity { get; set; } = "default-src 'self' 'unsafe-inline'";
28 |         public string XContentType { get; set; } = "nosniff";
29 |         public string XFrame { get; set; } = "SAMEORIGIN";
30 |     }
31 | 
32 |     public class CorsPolicyOptions
33 |     {
34 |         public string Name { get; set; } = "default";
35 |         public string[] Origins { get; set; } = new string[]{};
36 |         public string[] Methods { get; set; } = new string[]{};
37 |         public string[] Headers { get; set; } = new string[]{};
38 |         public bool AllowCredentials { get; set; }
39 |         public bool AllowAnyOrigin { get; set; }
40 |         public bool AllowAnyMethod { get; set; }
41 |         public bool AllowAnyHeader { get; set; }
42 |         public CorsPolicy Build()
43 |         {
44 |             CorsPolicyBuilder policy = new CorsPolicyBuilder();
45 |             if (AllowAnyOrigin) policy.AllowAnyOrigin(); else policy.WithOrigins(Origins);
46 |             if (AllowAnyMethod) policy.AllowAnyMethod(); else policy.WithMethods(Origins);
47 |             if (AllowAnyHeader) policy.AllowAnyHeader(); else policy.WithHeaders(Origins);
48 |             if (AllowCredentials && Origins?.Length > 0) policy.AllowCredentials(); else policy.DisallowCredentials();
49 |             return policy.Build();
50 |         }
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/docs/appliance/docker-compose.yml:
--------------------------------------------------------------------------------
 1 | version: '3'
 2 | 
 3 | services:
 4 |   nginx:
 5 |     image: nginx:1.17-alpine
 6 |     restart: unless-stopped
 7 |     ports:
 8 |       - 80:80
 9 |       - 443:443
10 |     volumes:
11 |       - ./vols/nginx/nginx.conf:/etc/nginx/nginx.conf
12 |       - ./vols/nginx/conf.d:/etc/nginx/conf.d
13 |       - ./vols/nginx/html:/usr/share/nginx/html
14 |     networks:
15 |       default:
16 |         aliases:
17 |           - id.foundry.local
18 |           - topomojo.foundry.local
19 | 
20 |     depends_on:
21 |       - topomojo
22 |       - identity
23 | 
24 |   identity:
25 |     image: cmusei/identity:1.3.0
26 |     restart: unless-stopped
27 |     entrypoint: ["bash", "/entry.d/entrypoint"]
28 |     command: ["dotnet", "IdentityServer.dll"]
29 |     environment:
30 |       APPSETTINGS_PATH: /app/conf/identity.conf
31 |     volumes:
32 |       - ./vols/entry.d:/entry.d
33 |       - ./vols/identity-conf:/app/conf
34 |     depends_on:
35 |       - postgres
36 | 
37 |   identity-ui:
38 |     image: cmusei/identity-ui:1.3.0
39 |     restart: unless-stopped
40 |     volumes:
41 |       - ./vols/identity-conf/identity-ui-settings.json:/var/www/ui/assets/settings.env.json
42 | 
43 |   appmail:
44 |     image: cmusei/appmailrelay:2.3.0
45 |     restart: unless-stopped
46 |     environment:
47 |       MAIL__HOST: ""
48 |       MAIL__USER: ""
49 |       MAIL__PASSWORD: ""
50 |       MAIL__PORT: 25
51 |       MAIL__SENDER: ""
52 |       RELAY__CLIENTKEYS__0: id.foundry.local#321ChangeMe!
53 | 
54 |   topomojo:
55 |     image: cmusei/topomojo:1.3.0
56 |     restart: unless-stopped
57 |     entrypoint: ["bash", "/entry.d/entrypoint"]
58 |     command: ["dotnet", "TopoMojo.Web.dll"]
59 |     volumes:
60 |       - ./vols/entry.d:/entry.d
61 |       - ./vols/topomojo-conf/topomojo.conf:/app/conf/appsettings.conf
62 |       - topomojo-nfs:/mnt/tm
63 |     depends_on:
64 |       - postgres
65 | 
66 |   topomojo-ui:
67 |     image: cmusei/topomojo-ui:1.3.0
68 |     restart: unless-stopped
69 |     volumes:
70 |       - ./vols/topomojo-conf/topomojo-ui-settings.json:/var/www/assets/config/settings.json
71 | 
72 |   postgres:
73 |     image: postgres:11.8
74 |     environment:
75 |       POSTGRES_PASSWORD: 321ChangeMe!
76 |     volumes:
77 |       - pgdata:/var/lib/postgresql/data
78 | 
79 | volumes:
80 |   pgdata:
81 |   topomojo-nfs:
82 |     # driver_opts:
83 |     #   type: "nfs"
84 |     #   o: "addr=<your nfs ip>,rw,nfsvers=4,async"
85 |     #   device: ":<your export path>"
86 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/Infrastructure/JsonExceptionMiddleware.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University.
 2 | // Released under a MIT (SEI) license. See LICENSE.md in the project root.
 3 | 
 4 | using System;
 5 | using System.Linq;
 6 | using System.Text.Json;
 7 | using System.Threading.Tasks;
 8 | using Microsoft.AspNetCore.Http;
 9 | using Microsoft.Extensions.Logging;
10 | using TopoMojo.Web;
11 | 
12 | namespace TopoMojo.Web
13 | {
14 |     public class JsonExceptionMiddleware
15 |     {
16 |         public JsonExceptionMiddleware(
17 |             RequestDelegate next,
18 |             ILogger<JsonExceptionMiddleware> logger
19 |         )
20 |         {
21 |             _next = next;
22 |             _logger = logger;
23 |         }
24 |         private readonly RequestDelegate _next;
25 |         private readonly ILogger _logger;
26 | 
27 |         public async Task Invoke(HttpContext context)
28 |         {
29 |             try {
30 |                 await _next(context);
31 |             }
32 |             catch (Exception ex)
33 |             {
34 |                 _logger.LogError(ex, "Error");
35 | 
36 |                 if (!context.Response.HasStarted)
37 |                 {
38 |                     context.Response.StatusCode = 500;
39 |                     string message = "Error";
40 |                     Type type = ex.GetType();
41 | 
42 |                     if (
43 |                         ex is System.InvalidOperationException
44 |                         || type.Namespace.StartsWith("TopoMojo")
45 |                     ) {
46 |                         context.Response.StatusCode = 400;
47 |                         // message = ex.Message;
48 |                         message = type.Name
49 |                             .Split('.')
50 |                             .Last()
51 |                             .Replace("Exception", "");
52 | 
53 |                         // message += $" {ex.Message}";
54 |                     }
55 | 
56 |                     await context.Response.WriteAsync(JsonSerializer.Serialize(new { message = message }));
57 |                 }
58 |             }
59 | 
60 |         }
61 |     }
62 | }
63 | 
64 | namespace Microsoft.AspNetCore.Builder
65 | {
66 |     public static class JsonExceptionStartupExtensions
67 |     {
68 |         public static IApplicationBuilder UseJsonExceptions (
69 |             this IApplicationBuilder builder
70 |         )
71 |         {
72 |             return builder.UseMiddleware<JsonExceptionMiddleware>();
73 |         }
74 |     }
75 | }
76 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Core/Data/Stores/_CachedStore.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University.
 2 | // Released under a MIT (SEI) license. See LICENSE.md in the project root.
 3 | 
 4 | using System;
 5 | using System.Threading.Tasks;
 6 | using Microsoft.Extensions.Caching.Distributed;
 7 | using Microsoft.Extensions.Caching.Memory;
 8 | using Newtonsoft.Json;
 9 | using TopoMojo.Data.Abstractions;
10 | 
11 | namespace TopoMojo.Data
12 | {
13 |     public abstract class CachedStore<TEntity> : DataStore<TEntity>
14 |         where TEntity : class, IEntity
15 |     {
16 |         public CachedStore(
17 |             TopoMojoDbContext dbContext,
18 |             IMemoryCache memoryCache,
19 |             IDistributedCache cache = null
20 |         ) : base(dbContext, memoryCache)
21 |         {
22 |             _cache = cache;
23 |         }
24 | 
25 |         protected IDistributedCache _cache { get; }
26 | 
27 |         protected JsonSerializerSettings _serializeSettings => new JsonSerializerSettings
28 |         {
29 |             ReferenceLoopHandling = ReferenceLoopHandling.Ignore
30 |         };
31 | 
32 |         protected DistributedCacheEntryOptions _cacheOptions => new DistributedCacheEntryOptions
33 |         {
34 |             SlidingExpiration = new TimeSpan(0, 15, 0)
35 |         };
36 | 
37 |         protected override async Task<object> FromCache(string key)
38 |         {
39 |             if (_cache == null)
40 |                 return null;
41 | 
42 |             TEntity entity = null;
43 | 
44 |             try
45 |             {
46 | 
47 |                 string v = await _cache.GetStringAsync(key);
48 | 
49 |                 if (!string.IsNullOrEmpty(v))
50 |                     entity = JsonConvert.DeserializeObject<TEntity>(v);
51 | 
52 |             }
53 |             catch
54 |             {
55 |             }
56 | 
57 |             return entity;
58 |         }
59 | 
60 |         protected override async Task ToCache(string key, TEntity value, DistributedCacheEntryOptions options = null)
61 |         {
62 |             if (_cache == null)
63 |                 return;
64 | 
65 |             try
66 |             {
67 |                 string v = JsonConvert.SerializeObject(value, _serializeSettings);
68 | 
69 |                 await _cache.SetStringAsync(key, v, options ?? _cacheOptions);
70 |             }
71 | 
72 |             catch {}
73 |         }
74 | 
75 |         protected override async Task UnCache(string key)
76 |         {
77 |             if (_cache != null)
78 |                 await _cache.RemoveAsync(key);
79 |         }
80 | 
81 |     }
82 | }
83 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Core/Services/Mappers/WorkspaceProfile.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System.Linq;
 5 | using AutoMapper;
 6 | using TopoMojo.Data.Extensions;
 7 | using TopoMojo.Extensions;
 8 | using TopoMojo.Models;
 9 | 
10 | namespace TopoMojo.Services
11 | {
12 |     public class WorkspaceProfile : Profile
13 |     {
14 |         public WorkspaceProfile()
15 |         {
16 |             CreateMap<Data.Workspace, Workspace>()
17 | 
18 |                 .ForMember(d => d.Slug, opt => opt.MapFrom(s => s.Name.ToSlug()))
19 | 
20 |                 .ForMember(d => d.Author, opt =>
21 |                     opt.MapFrom((s, d, m, r) => s.Author ?? s.Workers.FirstOrDefault()?.Person?.Name))
22 | 
23 |                 .ForMember(d => d.CanManage, opt =>
24 |                     opt.MapFrom((s, d, m, r) => s.CanManage(r.GetActor())))
25 | 
26 |                 .ForMember(d => d.CanEdit, opt =>
27 |                     opt.MapFrom((s, d, m, r) => s.CanEdit(r.GetActor())))
28 | 
29 |                 .ForMember(d => d.TemplateLimit, opt =>
30 |                     opt.MapFrom((s,d,m,r) => r.GetActor().IsCreator ? 0 : s.TemplateLimit))
31 | 
32 |                 .ForMember(d => d.WhenCreated, opt => opt.MapFrom(s => s.WhenCreated.ToString("u")))
33 | 
34 |                 .ForMember(d => d.GamespaceCount, opt => opt.MapFrom(s => s.Gamespaces.Count))
35 |             ;
36 | 
37 |             CreateMap<Data.Workspace, WorkspaceSummary>()
38 | 
39 |                 .ForMember(d => d.WhenCreated, opt => opt.MapFrom(s => s.WhenCreated.ToString("u")))
40 | 
41 |                 .ForMember(d => d.Slug, opt => opt.MapFrom(s => s.Name.ToSlug()))
42 | 
43 |                 .ForMember(d => d.CanManage, opt =>
44 |                     opt.MapFrom((s, d, m, r) => s.CanManage(r.GetActor())))
45 | 
46 |                 .ForMember(d => d.CanEdit, opt =>
47 |                     opt.MapFrom((s, d, m, r) => s.CanEdit(r.GetActor())))
48 |             ;
49 | 
50 |             CreateMap<Data.Workspace, WorkspaceInvitation>();
51 | 
52 |             CreateMap<NewWorkspace, Data.Workspace>();
53 | 
54 |             CreateMap<ChangedWorkspace, Data.Workspace>();
55 | 
56 |             CreateMap<Data.Worker, Worker>()
57 | 
58 |                 .ForMember(d => d.CanManage, opt => opt.MapFrom((s) => s.CanManage()))
59 | 
60 |                 .ForMember(d => d.CanEdit, opt => opt.MapFrom((s) => s.CanEdit()))
61 |             ;
62 | 
63 |         }
64 |     }
65 | }
66 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/Infrastructure/CrossSiteRequestMiddleware.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. 
 2 | // Released under a MIT (SEI) license. See LICENSE.md in the project root. 
 3 | 
 4 | using System;
 5 | using System.Linq;
 6 | using System.Security.Cryptography;
 7 | using System.Text;
 8 | using System.Threading.Tasks;
 9 | using Microsoft.AspNetCore.Http;
10 | 
11 | namespace Microsoft.Extensions.DependencyInjection
12 | {
13 |     public class CrossSiteRequestMiddleware
14 |     {
15 |         public CrossSiteRequestMiddleware(
16 |             RequestDelegate next
17 |         )
18 |         {
19 |             _next = next;
20 |             _random = new Random();
21 |             _hash = SHA256.Create();
22 | 
23 |         }
24 | 
25 |         private const string XSRFCOOKIE = "XSRF-TOKEN";
26 |         private const string AUTHCOOKIE = "Authorization";
27 |         private const string METHODS = "POST PUT DELETE";
28 |         private readonly RequestDelegate _next;
29 |         private Random _random;
30 |         private HashAlgorithm _hash;
31 | 
32 |         public async Task Invoke(HttpContext context)
33 |         {
34 |             if (METHODS.Contains(context.Request.Method))
35 |             {
36 |                 bool valid = true;
37 | 
38 |                 string challenge = context.Request.Cookies[XSRFCOOKIE];
39 |                 string response = context.Request.Headers["X-" + XSRFCOOKIE];
40 | 
41 |                 if (!string.IsNullOrWhiteSpace(challenge))
42 |                 {
43 |                     valid = response is string && (response.Equals(challenge) || response == "jam.dev");
44 |                 }
45 | 
46 |                 if (valid)
47 |                 {
48 |                     byte[] salt = Convert.FromBase64String(challenge.Split('.').First());
49 | 
50 |                     byte[] token = Encoding.UTF8.GetBytes(context.Request.Headers[AUTHCOOKIE]);
51 | 
52 |                     byte[] hash = _hash.ComputeHash(salt.Concat(token).ToArray());
53 | 
54 |                     string result = $"{Convert.ToBase64String(salt)}.{BitConverter.ToString(hash).Replace("-","").ToLower()}";
55 | 
56 |                     valid = result.Equals(challenge) || response.Equals("jam.dev");
57 |                 }
58 | 
59 |                 if (!valid)
60 |                 {
61 |                     context.Response.StatusCode = 400;
62 |                     await context.Response.WriteAsync("invalid xsrf-token");
63 |                     return;
64 |                 }
65 |             }
66 | 
67 |             await _next(context);
68 | 
69 |         }
70 |     }
71 | }
72 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Core/Data/Entities/Extensions/PermissionExtensions.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System.Linq;
 5 | using TopoMojo.Models;
 6 | 
 7 | namespace TopoMojo.Data.Extensions
 8 | {
 9 |     public static class PermissionExtensions
10 |     {
11 |         public static bool CanManage(this Permission flag)
12 |         {
13 |             return flag.HasFlag(Permission.Manager);
14 |         }
15 | 
16 |         public static bool CanEdit(this Permission flag)
17 |         {
18 |             return flag.HasFlag(Permission.Editor);
19 |         }
20 | 
21 |         public static bool CanManage(this Worker worker)
22 |         {
23 |             return worker.Permission.CanManage();
24 |         }
25 | 
26 |         public static bool CanEdit(this Worker worker)
27 |         {
28 |             return worker.Permission.CanEdit();
29 |         }
30 | 
31 |         public static bool CanManage(this Player player)
32 |         {
33 |             return player.Permission.CanManage();
34 |         }
35 | 
36 |         public static bool CanEdit(this Player player)
37 |         {
38 |             return player.Permission.CanEdit();
39 |         }
40 | 
41 |         public static bool CanManage(this Workspace workspace, Models.User user)
42 |         {
43 |             return user.IsAdmin
44 |                 || (workspace.Workers
45 |                     .FirstOrDefault(p => p.PersonId == user.Id)?
46 |                     .Permission.CanManage() ?? false);
47 |         }
48 | 
49 |         public static bool CanEdit(this Workspace workspace, Models.User user)
50 |         {
51 |             return user.IsAdmin
52 |                 || (workspace.Workers
53 |                     .FirstOrDefault(p => p.PersonId == user.Id)?
54 |                     .Permission.CanEdit() ?? false);
55 |         }
56 | 
57 |         public static bool CanManage(this Gamespace player, Models.User user)
58 |         {
59 |             return user.IsAdmin
60 |                 || (player.Players
61 |                     .FirstOrDefault(p => p.PersonId == user.Id)?
62 |                     .Permission.CanManage() ?? false);
63 |         }
64 | 
65 |         public static bool CanEdit(this Gamespace player, Models.User user)
66 |         {
67 |             return user.IsAdmin
68 |                 || (player.Players
69 |                     .FirstOrDefault(p => p.PersonId == user.Id)?
70 |                     .Permission.CanEdit() ?? false);
71 |         }
72 |     }
73 | }
74 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/Extensions/DatabaseExtensions.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System;
 5 | using System.IO;
 6 | using System.Linq;
 7 | using System.Text.Json;
 8 | using Microsoft.AspNetCore.Hosting;
 9 | using Microsoft.EntityFrameworkCore;
10 | using Microsoft.Extensions.Configuration;
11 | using Microsoft.Extensions.DependencyInjection;
12 | using Microsoft.Extensions.Hosting;
13 | using TopoMojo.Data;
14 | using TopoMojo.Web.Models;
15 | 
16 | namespace TopoMojo.Web.Extensions
17 | {
18 |     public static class DatabaseStartupExtensions
19 |     {
20 | 
21 |         public static IHost InitializeDatabase(
22 |             this IHost host
23 |         )
24 |         {
25 |             using (var scope = host.Services.CreateScope())
26 |             {
27 |                 var services = scope.ServiceProvider;
28 |                 IConfiguration config = services.GetRequiredService<IConfiguration>();
29 |                 IWebHostEnvironment env = services.GetService<IWebHostEnvironment>();
30 |                 DatabaseOptions options = config.GetSection("Database").Get<DatabaseOptions>()
31 |                     ?? new DatabaseOptions();
32 | 
33 |                 var dbContext = services.GetService<TopoMojoDbContext>();
34 | 
35 |                 if (!dbContext.Database.IsInMemory())
36 |                     dbContext.Database.Migrate();
37 | 
38 |                 string seedFile = Path.Combine(env.ContentRootPath, options.SeedFile);
39 | 
40 |                 if (File.Exists(seedFile)) {
41 | 
42 |                     DbSeedModel seedData = JsonSerializer.Deserialize<DbSeedModel>(
43 |                         File.ReadAllText(seedFile)
44 |                     );
45 | 
46 |                     foreach (var u in seedData.Users)
47 |                     {
48 |                         if (!dbContext.Users.Any(p => p.GlobalId == u.GlobalId))
49 |                         {
50 |                             dbContext.Users.Add(new TopoMojo.Data.User
51 |                             {
52 |                                 Name = u.Name,
53 |                                 GlobalId = u.GlobalId,
54 |                                 WhenCreated = DateTime.UtcNow,
55 |                                 Role = TopoMojo.Models.UserRole.Administrator
56 |                             });
57 |                         }
58 |                     }
59 |                     dbContext.SaveChanges();
60 |                 }
61 | 
62 |                 return host;
63 |             }
64 |         }
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/Extensions/ForwardingStartupExtensions.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University.
 2 | // Released under a MIT (SEI) license. See LICENSE.md in the project root.
 3 | 
 4 | using System;
 5 | using System.Linq;
 6 | using System.Net;
 7 | using Microsoft.AspNetCore.Builder;
 8 | using Microsoft.AspNetCore.HttpOverrides;
 9 | using TopoMojo.Web;
10 | 
11 | namespace Microsoft.Extensions.DependencyInjection
12 | {
13 |     public static class ForwardingStartupExtensions
14 |     {
15 | 
16 |         public static IServiceCollection ConfigureForwarding(
17 |             this IServiceCollection services,
18 |             ForwardHeaderOptions options
19 |         )
20 |         {
21 |             services.Configure<ForwardedHeadersOptions>(config => {
22 | 
23 |                 if (Enum.TryParse<ForwardedHeaders>(
24 |                     options.TargetHeaders ?? "None",
25 |                     true,
26 |                     out ForwardedHeaders targets)
27 |                 )
28 |                 {
29 |                     config.ForwardedHeaders = targets;
30 |                 }
31 | 
32 |                 config.ForwardLimit = options.ForwardLimit;
33 | 
34 |                 if (options.ForwardLimit == 0)
35 |                 {
36 |                     config.ForwardLimit = null;
37 |                 }
38 | 
39 |                 string nets = options.KnownNetworks;
40 |                 if (string.IsNullOrEmpty(nets))
41 |                     nets = "10.0.0.0/8 172.16.0.0/12 192.168.0.0/24 ::ffff:a00:0/104 ::ffff:b00a:0/108 ::ffff:c0d0:0/120";
42 | 
43 |                 foreach (string item in nets.Split(new char[] { ' ', ','}, StringSplitOptions.RemoveEmptyEntries))
44 |                 {
45 |                     string[] net = item.Split('/');
46 | 
47 |                     if (IPAddress.TryParse(net.First(), out IPAddress ipaddr)
48 |                         && Int32.TryParse(net.Last(), out int prefix)
49 |                     )
50 |                     {
51 |                         config.KnownNetworks.Add(new IPNetwork(ipaddr, prefix));
52 |                     }
53 |                 }
54 | 
55 |                 if (!string.IsNullOrEmpty(options.KnownProxies))
56 |                 {
57 |                     foreach (string ip in options.KnownProxies.Split(new char[] { ' ', ','}, StringSplitOptions.RemoveEmptyEntries))
58 |                     {
59 |                         if (IPAddress.TryParse(ip, out IPAddress ipaddr))
60 |                         {
61 |                             config.KnownProxies.Add(ipaddr);
62 |                         }
63 |                     }
64 |                 }
65 | 
66 |             });
67 | 
68 |             return services;
69 |         }
70 |     }
71 | }
72 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/Program.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System;
 5 | using System.IO;
 6 | using System.Linq;
 7 | using Microsoft.AspNetCore.Hosting;
 8 | using Microsoft.Extensions.Hosting;
 9 | using TopoMojo.Web.Extensions;
10 | 
11 | namespace TopoMojo.Web
12 | {
13 |     public class Program
14 |     {
15 |         public static void Main(string[] args)
16 |         {
17 |             Console.Title = "TopoMojo";
18 | 
19 |             LoadSettings();
20 | 
21 |             var hostBuilder = CreateHostBuilder(args)
22 |                 .Build()
23 |                 .InitializeDatabase();
24 | 
25 |             bool dbonly = args.ToList().Contains("--dbonly")
26 |                 || Environment.GetEnvironmentVariable("TOPOMOJO_DBONLY")?.ToLower() == "true";
27 | 
28 |             if (!dbonly)
29 |                 hostBuilder.Run();
30 | 
31 |         }
32 | 
33 |         public static IHostBuilder CreateHostBuilder(string[] args) =>
34 |             Host.CreateDefaultBuilder(args)
35 |                 .ConfigureWebHostDefaults(webBuilder =>
36 |                 {
37 |                     webBuilder.UseStartup<Startup>();
38 |                 });
39 | 
40 |         public static void LoadSettings()
41 |         {
42 |             string envname = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
43 |             string path = Environment.GetEnvironmentVariable("APPSETTINGS_PATH") ?? "./conf/appsettings.conf";
44 |             ConfToEnv("appsettings.conf");
45 |             ConfToEnv($"appsettings.{envname}.conf");
46 |             ConfToEnv(path);
47 |         }
48 | 
49 |         public static void ConfToEnv(string conf)
50 |         {
51 |             if (!File.Exists(conf))
52 |                 return;
53 | 
54 |             try
55 |             {
56 |                 foreach (string line in File.ReadAllLines(conf))
57 |                 {
58 |                     if (
59 |                         line.Equals(string.Empty)
60 |                         || line.Trim().StartsWith("#")
61 |                         || !line.Contains("=")
62 |                     )
63 |                     {
64 |                         continue;
65 |                     }
66 | 
67 |                     int x = line.IndexOf("=");
68 | 
69 |                     Environment.SetEnvironmentVariable(
70 |                         line.Substring(0, x).Trim(),
71 |                         line.Substring(x + 1).Trim()
72 |                     );
73 |                 }
74 |             }
75 |             catch {}
76 |         }
77 |     }
78 | }
79 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/Infrastructure/FileUploadMonitor.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System;
 5 | using System.Collections.Generic;
 6 | using System.Linq;
 7 | using System.Threading.Tasks;
 8 | using Microsoft.Extensions.Logging;
 9 | 
10 | namespace TopoMojo.Web.Services
11 | {
12 |     public interface IFileUploadMonitor
13 |     {
14 |         void Update(string key, int progress);
15 |         FileProgress Check(string key);
16 |     }
17 | 
18 | 
19 |     public class FileUploadMonitor : IFileUploadMonitor
20 |     {
21 |         public FileUploadMonitor(ILogger<FileUploadMonitor> logger)
22 |         {
23 |             _logger = logger;
24 |             _monitor = new Dictionary<string, FileProgress>();
25 |             Task task = CleanupLoop();
26 |         }
27 |         private readonly ILogger<FileUploadMonitor> _logger;
28 |         private Dictionary<string, FileProgress> _monitor;
29 | 
30 |         public void Update(string key, int progress)
31 |         {
32 |             if (_monitor.ContainsKey(key))
33 |             {
34 |                 _monitor[key].Progress = progress;
35 |                 _monitor[key].Stop = DateTime.UtcNow;
36 |             }
37 |             else
38 |             {
39 |                 _monitor.Add(key, new FileProgress
40 |                 {
41 |                     Key = key,
42 |                     Progress = 0,
43 |                     Start = DateTime.UtcNow
44 |                 });
45 |             }
46 |         }
47 | 
48 |         public FileProgress Check(string key)
49 |         {
50 |             if (_monitor.ContainsKey(key))
51 |                 return _monitor[key];
52 | 
53 |             return new FileProgress { Key = key, Progress = -1 };
54 |         }
55 | 
56 |         private async Task CleanupLoop()
57 |         {
58 |             while (true)
59 |             {
60 |                 DateTime now = DateTime.UtcNow;
61 |                 foreach(FileProgress item in _monitor.Values.ToArray())
62 |                 {
63 |                     if (now.CompareTo(item.Stop.AddMinutes(2)) > 0)
64 |                     {
65 |                         _logger.LogDebug("removed monitor " + item.Key);
66 |                         _monitor.Remove(item.Key);
67 |                     }
68 |                 }
69 |                 await Task.Delay(60000);
70 |             }
71 |         }
72 |     }
73 | 
74 |     public class FileProgress
75 |     {
76 |         public string Key { get; set; }
77 |         public string Name { get; set; }
78 |         public int Progress { get; set; }
79 |         public DateTime Start { get; set; }
80 |         public DateTime Stop { get; set; }
81 |     }
82 | }
83 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Abstractions/Models/WorkspaceModels.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | namespace TopoMojo.Models
 5 | {
 6 |     public class Workspace
 7 |     {
 8 |         public int Id { get; set; }
 9 |         public string GlobalId { get; set; }
10 |         public string Name { get; set; }
11 |         public string Slug { get; set; }
12 |         public string Description { get; set; }
13 |         public string DocumentUrl { get; set; }
14 |         public string Author { get; set; }
15 |         public string Audience { get; set; }
16 |         public string WhenCreated { get; set; }
17 |         public bool CanManage { get; set; }
18 |         public bool CanEdit { get; set; }
19 |         public int TemplateLimit { get; set; }
20 |         public bool IsPublished { get; set; }
21 |         public int GamespaceCount { get; set; }
22 |         public string Challenge { get; set; }
23 |         public Worker[] Workers { get; set; }
24 |         public Template[] Templates { get; set; }
25 |     }
26 | 
27 |     public class WorkspaceSummary
28 |     {
29 |         public int Id { get; set; }
30 |         public string GlobalId { get; set; }
31 |         public string Name { get; set; }
32 |         public string Slug { get; set; }
33 |         public string Description { get; set; }
34 |         public bool CanManage { get; set; }
35 |         public bool CanEdit { get; set; }
36 |         public bool IsPublished { get; set; }
37 |         public string Audience { get; set; }
38 |         public string Author { get; set; }
39 |         public string WhenCreated { get; set; }
40 |     }
41 | 
42 |     public class NewWorkspace
43 |     {
44 |         public string Name { get; set; }
45 |         public string Description { get; set; }
46 |     }
47 | 
48 |     public class ChangedWorkspace
49 |     {
50 |         public int Id { get; set; }
51 |         public string Name { get; set; }
52 |         public string Description { get; set; }
53 |         public string Author { get; set; }
54 |         public bool IsPublished { get; set; }
55 |         public string Audience { get; set; }
56 |         public string DocumentUrl { get; set; }
57 |         public int TemplateLimit { get; set; }
58 |     }
59 | 
60 |     public class WorkspaceInvitation
61 |     {
62 |         public int Id { get; set; }
63 |         public string ShareCode { get; set; }
64 |     }
65 | 
66 |     public class Worker
67 |     {
68 |         public int Id { get; set; }
69 |         public string PersonName { get; set; }
70 |         public string PersonGlobalId { get; set; }
71 |         public bool CanManage { get; set; }
72 |         public bool CanEdit { get; set; }
73 |     }
74 | 
75 | }
76 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Client/TopoMojoStub.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University.
 2 | // Released under a MIT (SEI) license. See LICENSE.md in the project root.
 3 | 
 4 | using System;
 5 | using System.Threading.Tasks;
 6 | using TopoMojo.Abstractions;
 7 | using TopoMojo.Models;
 8 | 
 9 | namespace TopoMojo.Client
10 | {
11 |     public class TopoMojoStub : ITopoMojoClient
12 |     {
13 |         public async Task<WorkspaceSummary[]> List(Search search)
14 |         {
15 |             await Task.Delay(0);
16 |             return new WorkspaceSummary[] {};
17 |         }
18 | 
19 |         public async Task BuildIso(IsoBuildSpec spec)
20 |         {
21 |             await Task.Delay(0);
22 |         }
23 | 
24 |         public async Task ChangeVm(VmAction vmAction)
25 |         {
26 |             await Task.Delay(0);
27 |         }
28 | 
29 |         public async Task<GameState> Start(GamespaceSpec spec)
30 |         {
31 |             await Task.Delay(0);
32 | 
33 |             return new GameState
34 |             {
35 |                 Id = 1,
36 |                 Name = "Mock Gamespace",
37 |                 GlobalId = spec.IsolationId,
38 |                 Vms = new VmState[]
39 |                 {
40 |                     new VmState
41 |                     {
42 |                         Id = Guid.NewGuid().ToString(),
43 |                         Name = "mock-vm",
44 |                         TemplateId = 1,
45 |                         IsRunning = true
46 |                     }
47 |                 }
48 |             };
49 |         }
50 | 
51 |         public async Task<string> Start(string problemId, GamespaceSpec workspace)
52 |         {
53 |             await Task.Delay(0);
54 |             return "mock gamespace markdown document";
55 |         }
56 | 
57 |         public async Task Stop(string problemId)
58 |         {
59 |             await Task.Delay(0);
60 |         }
61 | 
62 |         public async Task<string> Templates(int id)
63 |         {
64 |             await Task.Delay(0);
65 |             return "mock workspace templates";
66 |         }
67 | 
68 |         public async Task<ConsoleSummary> Ticket(string vmId)
69 |         {
70 |             await Task.Delay(0);
71 |             return new ConsoleSummary {
72 |                 Id = "12345",
73 |                 Name = "mockvm",
74 |                 Url = "/ticket/9876543210"
75 |             };
76 |         }
77 | 
78 |         public async Task<Registration> Register(RegistrationRequest request)
79 |         {
80 |             throw new NotImplementedException();
81 |         }
82 | 
83 |         public async Task<Challenge> Grade(Challenge challenge)
84 |         {
85 |             throw new NotImplementedException();
86 |         }
87 | 
88 |         public async Task<Challenge> Hints(Challenge challenge)
89 |         {
90 |             throw new NotImplementedException();
91 |         }
92 |     }
93 | }
94 | 


--------------------------------------------------------------------------------
/test/TopoMojo.Core.Tests/CoreTest.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2019 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System;
 5 | using Microsoft.EntityFrameworkCore;
 6 | using Microsoft.Extensions.Options;
 7 | using Microsoft.Extensions.Logging;
 8 | using TopoMojo.Abstractions;
 9 | using TopoMojo;
10 | using TopoMojo.Models;
11 | using TopoMojo.Data;
12 | using Xunit;
13 | using AutoMapper;
14 | using Microsoft.Extensions.DependencyInjection;
15 | using Microsoft.Extensions.Caching.Distributed;
16 | using Microsoft.Extensions.Caching.Memory;
17 | 
18 | namespace Tests
19 | {
20 |     public class CoreTest
21 |     {
22 |         public CoreTest()
23 |         {
24 |             Initialize();
25 |         }
26 | 
27 |         protected IIdentityResolver _ur = null;
28 |         protected const string _complexPassword = "~Tartans@1~";
29 |         protected IOptions<CoreOptions> _optAccessor = null;
30 |         protected CoreOptions _options = null;
31 | 
32 |         protected TopoMojo.Models.User _user = null;
33 |         protected ILoggerFactory _mill = null;
34 |         private DbContextOptions<TopoMojoDbContext> _dbOptions;
35 | 
36 |         protected IMapper Mapper { get; set; }
37 |         protected IDistributedCache Cache { get; set; }
38 |         protected IMemoryCache MemoryCache { get; set;
39 |         }
40 |         protected TestSession CreateSession()
41 |         {
42 |             return new TestSession(
43 |                 CreateContext(),
44 |                 _options,
45 |                 _mill,
46 |                 Mapper,
47 |                 Cache,
48 |                 MemoryCache
49 |             );
50 |         }
51 | 
52 |         protected TopoMojoDbContext CreateContext()
53 |         {
54 |             return new TopoMojoDbContext(_dbOptions);
55 |         }
56 | 
57 |         protected void Initialize()
58 |         {
59 |             _options = new CoreOptions();
60 |             _mill = new LoggerFactory();
61 | 
62 |             Mapper = new AutoMapper.MapperConfiguration(cfg => {
63 |                 cfg.AddTopoMojoMaps();
64 |             }).CreateMapper();
65 | 
66 |             Cache = new StubDistributedCache();
67 |             MemoryCache = new StubMemoryCache();
68 | 
69 |             _dbOptions = new DbContextOptionsBuilder<TopoMojoDbContext>()
70 |                 .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
71 |                 .Options;
72 | 
73 |             using (TopoMojoDbContext ctx = new TopoMojoDbContext(_dbOptions))
74 |             {
75 |                 ctx.Database.EnsureDeleted();
76 |                 ctx.Database.EnsureCreated();
77 |                 _user = new TopoMojo.Models.User { Id = 1, Name = "tester" };
78 |                 _ur = new IdentityResolver(_user);
79 |             }
80 | 
81 |         }
82 |     }
83 | }
84 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Core/Data/Stores/TEntityStore.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System;
 5 | using System.Linq;
 6 | using System.Threading.Tasks;
 7 | using Microsoft.EntityFrameworkCore;
 8 | using TopoMojo.Data.Abstractions;
 9 | using TopoMojo.Extensions;
10 | 
11 | namespace TopoMojo.Data
12 | {
13 |     public abstract class Store<TEntity> : IStore<TEntity>
14 |         where TEntity : class, IEntity
15 |     {
16 |         protected TopoMojoDbContext DbContext { get; }
17 | 
18 |         public Store(TopoMojoDbContext dbContext)
19 |         {
20 |             DbContext = dbContext;
21 |         }
22 | 
23 |         public virtual async Task<TEntity> Add(TEntity entity)
24 |         {
25 |             // entity.Name = entity.Name ?? $"[{typeof(TEntity).Name}Name]";
26 |             entity.WhenCreated = DateTime.UtcNow;
27 | 
28 |             if (!entity.GlobalId.HasValue() || !Guid.TryParse(entity.GlobalId, out Guid guid))
29 |                 entity.GlobalId = Guid.NewGuid().ToString();
30 | 
31 |             DbContext.Add(entity);
32 | 
33 |             await DbContext.SaveChangesAsync();
34 | 
35 |             return entity;
36 |         }
37 | 
38 |         public virtual async Task Update(TEntity entity)
39 |         {
40 |             // entity.Name = entity.Name ?? $"[{typeof(TEntity).Name}Name]";
41 | 
42 |             DbContext.Update(entity);
43 | 
44 |             await DbContext.SaveChangesAsync();
45 |         }
46 | 
47 |         public virtual async Task Remove(TEntity entity)
48 |         {
49 |             DbContext.Set<TEntity>().Remove(entity);
50 |             await DbContext.SaveChangesAsync();
51 |         }
52 | 
53 |         public virtual async Task<TEntity> Load(int id)
54 |         {
55 |             return await DbContext.Set<TEntity>().FindAsync(id);
56 |         }
57 | 
58 |         public virtual async Task<TEntity> FindByGlobalId(string guid)
59 |         {
60 |             int id = await DbContext.Set<TEntity>()
61 |                 .Where(e => e.GlobalId == guid)
62 |                 .Select(e => e.Id)
63 |                 .SingleOrDefaultAsync();
64 | 
65 |             return await Load(id);
66 |         }
67 | 
68 |         public virtual IQueryable<TEntity> List()
69 |         {
70 |             return DbContext.Set<TEntity>();
71 |         }
72 | 
73 |         public virtual async Task<bool> CanEdit(int id, User profile)
74 |         {
75 |             return await Task.FromResult(false);
76 |         }
77 | 
78 |         public virtual async Task<bool> CanManage(int id, User profile)
79 |         {
80 |             return await Task.FromResult(false);
81 |         }
82 |     }
83 | 
84 |     public class RepositoryContext : IStoreUserContext
85 |     {
86 |         public int UserId { get; set; }
87 |         public bool UserIsAdmin { get; set; }
88 |     }
89 | }
90 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/Infrastructure/BearerCookieMiddleware.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. 
 2 | // Released under a MIT (SEI) license. See LICENSE.md in the project root. 
 3 | 
 4 | using System;
 5 | using System.Linq;
 6 | using System.Security.Cryptography;
 7 | using System.Text;
 8 | using System.Threading.Tasks;
 9 | using Microsoft.AspNetCore.Http;
10 | using Microsoft.Extensions.Hosting;
11 | 
12 | namespace Microsoft.Extensions.DependencyInjection
13 | {
14 |     public class BearerCookieMiddleware
15 |     {
16 |         public BearerCookieMiddleware(
17 |             RequestDelegate next,
18 |             IHostEnvironment environment,
19 |             string endpoint
20 |         )
21 |         {
22 |             _next = next;
23 |             _endpoint = endpoint;
24 |             _dev = environment.IsDevelopment();
25 |             _cookieOptions = new CookieOptions
26 |             {
27 |                 HttpOnly = true,
28 |                 SameSite = SameSiteMode.Strict
29 |             };
30 | 
31 |             _random = new Random();
32 |             _hash = SHA256.Create();
33 |         }
34 | 
35 |         private const string HEADER = "Authorization";
36 |         private readonly RequestDelegate _next;
37 |         private string _endpoint;
38 |         private bool _dev;
39 |         private CookieOptions _cookieOptions;
40 |         private Random _random;
41 |         private HashAlgorithm _hash;
42 | 
43 |         public async Task Invoke(HttpContext context)
44 |         {
45 |             if (
46 |                 !context.Request.Headers.ContainsKey(HEADER)
47 |                 && context.Request.Cookies.ContainsKey(HEADER)
48 |             )
49 |             {
50 |                 context.Request.Headers.Add(HEADER, context.Request.Cookies[HEADER]);
51 |             }
52 | 
53 |             if (
54 |                 !string.IsNullOrWhiteSpace(_endpoint)
55 |                 && _endpoint.StartsWith(context.Request.Method)
56 |                 && _endpoint.EndsWith(context.Request.Path)
57 |             )
58 |             {
59 |                 context.Response.Cookies.Append(
60 |                     HEADER,
61 |                     context.Request.Headers[HEADER],
62 |                     _cookieOptions
63 |                 );
64 | 
65 |                 if (!_dev || true)
66 |                 {
67 |                     byte[] salt = new byte[18];
68 |                     _random.NextBytes(salt);
69 | 
70 |                     byte[] token = Encoding.UTF8.GetBytes(context.Request.Headers[HEADER]);
71 | 
72 |                     byte[] hash = _hash.ComputeHash(salt.Concat(token).ToArray());
73 | 
74 |                     string result = $"{Convert.ToBase64String(salt)}.{BitConverter.ToString(hash)}";
75 | 
76 |                     context.Response.Cookies.Append("XSRF-TOKEN", result.Replace("-","").ToLower());
77 |                 }
78 |             }
79 | 
80 |             await _next(context);
81 | 
82 |         }
83 |     }
84 | }
85 | 


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
 1 | TopoMojo
 2 | 
 3 | Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 4 | 
 5 | Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
 6 | 
 7 | 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
 8 | 
 9 | 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
10 | 
11 | 3. Products derived from this software may not include “Carnegie Mellon University,” "SEI” and/or “Software Engineering Institute" in the name of such derived product, nor shall “Carnegie Mellon University,” "SEI” and/or “Software Engineering Institute" be used to endorse or promote products derived from this software without prior written permission. For written permission, please contact permission@sei.cmu.edu.
12 | 
13 | ACKNOWLEDGMENTS AND DISCLAIMERS:
14 | 
15 | This program includes and/or can make use of certain third party source code, object code, documentation and other files ("Third Party Software"). The Third Party Software that is used by this program is dependent upon your system configuration. By using this program, You agree to comply with any and all relevant Third Party Software terms and conditions contained in any such Third Party Software or separate license file distributed with such Third Party Software. The parties who own the Third Party Software ("Third Party Licensors") are intended third party beneficiaries to this License with respect to the terms applicable to their Third Party Software. Third Party Software licenses only apply to the Third Party Software and not any other portion of this program or this program as a whole.
16 | 
17 | This material is based upon work funded and supported by the Department of Defense under Contract No. FA8702-15-D-0002 with Carnegie Mellon University for the operation of the Software Engineering Institute, a federally funded research and development center.
18 | 
19 | The view, opinions, and/or findings contained in this material are those of the author(s) and should not be construed as an official Government position, policy, or decision, unless designated by other documentation.
20 | 
21 | NO WARRANTY. THIS CARNEGIE MELLON UNIVERSITY AND SOFTWARE ENGINEERING INSTITUTE MATERIAL IS FURNISHED ON AN "AS-IS" BASIS. CARNEGIE MELLON UNIVERSITY MAKES NO WARRANTIES OF ANY KIND, EITHER EXPRESSED OR IMPLIED, AS TO ANY MATTER INCLUDING, BUT NOT LIMITED TO, WARRANTY OF FITNESS FOR PURPOSE OR MERCHANTABILITY, EXCLUSIVITY, OR RESULTS OBTAINED FROM USE OF THE MATERIAL. CARNEGIE MELLON UNIVERSITY DOES NOT MAKE ANY WARRANTY OF ANY KIND WITH RESPECT TO FREEDOM FROM PATENT, TRADEMARK, OR COPYRIGHT INFRINGEMENT.
22 | 
23 | [DISTRIBUTION STATEMENT A] This material has been approved for public release and unlimited distribution.  Please see Copyright notice for non-US Government use and distribution.
24 | 
25 | DM19-0532
26 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Abstractions/Models/TemplateModels.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | namespace TopoMojo.Models
 5 | {
 6 |     public class Template
 7 |     {
 8 |         public int Id { get; set; }
 9 |         public int ParentId { get; set; }
10 |         public bool CanEdit { get; set; }
11 |         public string Name { get; set; }
12 |         public string Description { get; set; }
13 |         public string Networks { get; set; }
14 |         public string Iso { get; set; }
15 |         public string Guestinfo { get; set; }
16 |         public bool IsHidden { get; set; }
17 |         public int WorkspaceId { get; set; }
18 |         public string WorkspaceGlobalId { get; set; }
19 |     }
20 | 
21 |     public class ChangedTemplate
22 |     {
23 |         public int Id { get; set; }
24 |         public string Name { get; set; }
25 |         public string Description { get; set; }
26 |         public string Networks { get; set; }
27 |         public string Iso { get; set; }
28 |         public bool IsHidden { get; set; }
29 |         public string Guestinfo { get; set; }
30 |         public int WorkspaceId { get; set; }
31 |     }
32 | 
33 |     public class NewTemplateDetail
34 |     {
35 |         public string Name { get; set; }
36 |         public string Networks { get; set; }
37 |         public string Detail { get; set; }
38 |         public bool IsPublished { get; set; }
39 |     }
40 | 
41 |     public class TemplateDetail
42 |     {
43 |         public int Id { get; set; }
44 |         public string Name { get; set; }
45 |         public string Description { get; set; }
46 |         public string Networks { get; set; }
47 |         public string Guestinfo { get; set; }
48 |         public string Detail { get; set; }
49 |         public bool IsPublished { get; set; }
50 |     }
51 | 
52 |     public class TemplateSummary
53 |     {
54 |         public int Id { get; set; }
55 |         public string Name { get; set; }
56 |         public string Description { get; set; }
57 |         public int WorkspaceId { get; set; }
58 |         public string WorkspaceName { get; set; }
59 |         public string ParentId { get; set; }
60 |         public string ParentName { get; set; }
61 |         public bool IsPublished { get; set; }
62 |     }
63 | 
64 |     public class TemplateLink
65 |     {
66 |         public int TemplateId { get; set; }
67 |         public int WorkspaceId { get; set; }
68 |     }
69 | 
70 |     public class ConvergedTemplate
71 |     {
72 |         public int Id { get; set; }
73 |         public string Name { get; set; }
74 |         public string Networks { get; set; }
75 |         public string Iso { get; set; }
76 |         public string Detail { get; set; }
77 |         public string Guestinfo { get; set; }
78 |         public int WorkspaceId { get; set; }
79 |         public string WorkspaceGlobalId { get; set; }
80 |         public bool WorkspaceUseUplinkSwitch { get; set; }
81 |     }
82 | }
83 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Core/Data/Stores/TemplateStore.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System.Linq;
 5 | using System.Threading.Tasks;
 6 | using Microsoft.EntityFrameworkCore;
 7 | using Microsoft.Extensions.Caching.Distributed;
 8 | using Microsoft.Extensions.Caching.Memory;
 9 | using TopoMojo.Data.Abstractions;
10 | 
11 | namespace TopoMojo.Data
12 | {
13 |     public class TemplateStore : DataStore<Template>, ITemplateStore
14 |     {
15 |         public TemplateStore (
16 |             TopoMojoDbContext db,
17 |             IMemoryCache memoryCache,
18 |             IDistributedCache cache
19 |         ) : base(db, memoryCache) { }
20 | 
21 |         public override IQueryable<Template> List(string term = null)
22 |         {
23 |             return base.List(term)
24 |                 .Include(t => t.Workspace);
25 |         }
26 | 
27 |         public override async Task<Template> Load(int id)
28 |         {
29 |             return await base.Load(id, query => query
30 |                 .Include(tt => tt.Parent)
31 |                 .Include(tt => tt.Workspace)
32 |                 .ThenInclude(t => t.Workers)
33 |             );
34 |         }
35 | 
36 |         public override async Task<Template> Load(string id)
37 |         {
38 |             return await base.Load(id, query => query
39 |                 .Include(tt => tt.Parent)
40 |                 .Include(tt => tt.Workspace)
41 |                 .ThenInclude(t => t.Workers)
42 |             );
43 |         }
44 | 
45 |         public async Task<bool> IsParentTemplate(int id)
46 |         {
47 |              return await DbContext.Templates
48 |                 .Where(t => t.ParentId == id)
49 |                 .AnyAsync();
50 |         }
51 | 
52 |         public async Task<Template[]> ListChildren(int parentId)
53 |         {
54 |             return await base.List()
55 |                 .Include(t => t.Workspace)
56 |                 .Where(t => t.ParentId == parentId)
57 |                 .ToArrayAsync();
58 |         }
59 | 
60 |         public async Task<bool> AtTemplateLimit(int topoId)
61 |         {
62 |             Workspace topo = await DbContext.Workspaces.FindAsync(topoId);
63 |             int count = await DbContext.Templates.Where(t => t.WorkspaceId == topoId).CountAsync();
64 |             return count >= topo.TemplateLimit;
65 |         }
66 | 
67 |         public async Task<string> ResolveKey(string key)
68 |         {
69 |             var name = await DbContext.Workspaces.Where(t => t.GlobalId == key)
70 |                 .Select(t => t.Name)
71 |                 .SingleOrDefaultAsync();
72 | 
73 |             if (!string.IsNullOrEmpty(name))
74 |                 return "workspace: " + name;
75 | 
76 |             name = await DbContext.Gamespaces.Where(g => g.GlobalId == key)
77 |                 .Select(g => g.Name)
78 |                 .SingleOrDefaultAsync();
79 | 
80 |             if (!string.IsNullOrEmpty(name))
81 |                 return "gamespace: " + name;
82 | 
83 |             return null;
84 |         }
85 |     }
86 | }
87 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/Controllers/ChatController.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System.Threading.Tasks;
 5 | using Microsoft.AspNetCore.Authorization;
 6 | using Microsoft.AspNetCore.Mvc;
 7 | using Microsoft.AspNetCore.SignalR;
 8 | using Microsoft.Extensions.Logging;
 9 | using TopoMojo.Abstractions;
10 | using TopoMojo.Models;
11 | using TopoMojo.Services;
12 | 
13 | namespace TopoMojo.Web.Controllers
14 | {
15 |     [Authorize]
16 |     public class ChatController : _Controller
17 |     {
18 |         public ChatController(
19 |             ILogger<AdminController> logger,
20 |             IIdentityResolver identityResolver,
21 |             ChatService chatService,
22 |             IHubContext<TopologyHub, ITopoEvent> hub
23 |         ) : base(logger, identityResolver)
24 |         {
25 |             _chatService = chatService;
26 |             _hub = hub;
27 |         }
28 | 
29 |         private readonly ChatService _chatService;
30 |         private readonly IHubContext<TopologyHub, ITopoEvent> _hub;
31 | 
32 |         [HttpGet("api/chats/{id}")]
33 |         public async Task<ActionResult<Message[]>> List(string id, int marker, int take = 25)
34 |         {
35 |             var result = await _chatService.List(id, take, marker);
36 |             return result;
37 |         }
38 | 
39 |         [HttpGet("api/chat/{id}")]
40 |         public async Task<ActionResult<Message>> GetMessage(int id)
41 |         {
42 |             var result = await _chatService.Find(id);
43 |             return result;
44 |         }
45 | 
46 |         [HttpPost("api/chat")]
47 |         [ProducesResponseType(201)]
48 |         public async Task<ActionResult> Add([FromBody]NewMessage model)
49 |         {
50 |             var msg = await _chatService.Add(model);
51 |             SendBroadcast(msg.RoomId, "added", msg);
52 |             return CreatedAtAction(nameof(GetMessage), new { id = msg.Id }, msg);
53 |         }
54 | 
55 |         [HttpPut("api/chat")]
56 |         [ProducesResponseType(200)]
57 |         public async Task<ActionResult> Update([FromBody]ChangedMessage model)
58 |         {
59 |             var msg = await _chatService.Update(model);
60 |             SendBroadcast(msg.RoomId, "updated", msg);
61 |             return Ok();
62 |         }
63 | 
64 |         [HttpDelete("api/chat/{id}")]
65 |         [ProducesResponseType(200)]
66 |         public async Task<ActionResult> Delete([FromRoute]int id)
67 |         {
68 |             var msg = await _chatService.Delete(id);
69 |             SendBroadcast(msg.RoomId, "deleted", msg);
70 |             return Ok();
71 |         }
72 | 
73 |         private void SendBroadcast(string roomId, string action, Message msg)
74 |         {
75 |             _hub.Clients
76 |                 .Group(roomId)
77 |                 .ChatEvent(
78 |                     new BroadcastEvent<Message>(
79 |                         User,
80 |                         "CHAT." + action.ToUpper(),
81 |                         msg
82 |                     )
83 |                 );
84 |         }
85 |     }
86 | }
87 | 


--------------------------------------------------------------------------------
/test/TopoMojo.Core.Tests/TopoTest.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2019 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using TopoMojo;
 5 | using TopoMojo.Models;
 6 | using TopoMojo.Services;
 7 | using Xunit;
 8 | 
 9 | namespace Tests
10 | {
11 |     public class TopologyTests : CoreTest
12 |     {
13 |         [Fact]
14 |         public void CanCreateAndEditWorkspace()
15 |         {
16 |             using (TestSession test = CreateSession())
17 |             {
18 |                 _options.DefaultWorkspaceLimit = 3;
19 |                 test.AddActor("jam@this.ws");
20 |                 WorkspaceService mgr = test.GetTopologyManager();
21 |                 Workspace topo = mgr.Create(new NewWorkspace {
22 |                     Name = "JamOn",
23 |                     Description = "original"
24 |                 }).Result;
25 | 
26 |                 Assert.True(topo.Id > 0);
27 |                 Assert.True(topo.CanManage);
28 |                 Assert.True(topo.CanEdit);
29 | 
30 |                 topo = mgr.Update(new ChangedWorkspace {
31 |                     Id = topo.Id,
32 |                     Name = topo.Name + "Changed",
33 |                     Description = topo.Description}).Result;
34 |                 Assert.Matches("Changed", topo.Name);
35 |                 Assert.Equal("original", topo.Description);
36 |             }
37 |         }
38 | 
39 |         [Fact]
40 |         public void ListReturnsList()
41 |         {
42 |             using (TestSession test = CreateSession())
43 |             {
44 |                 test.AddActor("jam@this.ws");
45 |                 WorkspaceService mgr = test.GetTopologyManager();
46 |                 for (int i = 0; i < 5; i++)
47 |                 {
48 |                     Workspace topo = mgr.Create(new NewWorkspace {
49 |                         Name = "JamOn" + i.ToString(),
50 |                         Description = i.ToString()
51 |                     }).Result;
52 | 
53 |                     if (i > 2)
54 |                     {
55 |                         topo.IsPublished = true;
56 |                         mgr.Update(new ChangedWorkspace
57 |                         {
58 |                             Id = topo.Id,
59 |                             Name = topo.Name,
60 |                             Description = topo.Description,
61 |                             Author = topo.Author,
62 |                             IsPublished = true,
63 |                             Audience = topo.Audience,
64 |                             TemplateLimit = topo.TemplateLimit
65 |                         }).Wait();
66 |                         // mgr.Publish(topo.Id, false).Wait();
67 |                     }
68 |                 }
69 | 
70 |                 var list = mgr.List(new Search {
71 |                     Take = 50,
72 |                     //Term = "2",
73 |                     Filter = new string[] {
74 |                         "published",
75 |                         "mine"
76 |                     }
77 |                 }).Result;
78 |                 Assert.True(list.Length == 2);
79 |             }
80 |         }
81 |     }
82 | }
83 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Core/Data/Stores/UserStore.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using System;
 5 | using System.Linq;
 6 | using System.Threading.Tasks;
 7 | using Microsoft.EntityFrameworkCore;
 8 | using Microsoft.Extensions.Caching.Distributed;
 9 | using Microsoft.Extensions.Caching.Memory;
10 | using TopoMojo.Data.Abstractions;
11 | using TopoMojo.Data.Extensions;
12 | using TopoMojo.Extensions;
13 | using TopoMojo.Models;
14 | 
15 | namespace TopoMojo.Data
16 | {
17 |     public class UserStore : CachedStore<User>, IUserStore
18 |     {
19 |         public UserStore (
20 |             TopoMojoDbContext db,
21 |             IMemoryCache memoryCache,
22 |             IDistributedCache cache
23 |         ) : base(db, memoryCache, cache)
24 |         {
25 | 
26 |         }
27 | 
28 |         public async Task<User> LoadDetail(int id)
29 |         {
30 |             return await DbContext.Users
31 |                 .Include(p => p.Workspaces)
32 |                 .Include(p => p.Gamespaces)
33 |                 .Where(p => p.Id == id)
34 |                 .FirstAsync();
35 |         }
36 | 
37 |         public override async Task<User> Add(User user)
38 |         {
39 |             string name = user.Name.ExtractBefore("@");
40 | 
41 |             if (!name.HasValue())
42 |                 user.Name = "Anonymous";
43 | 
44 |             if (!user.GlobalId.HasValue())
45 |                 user.GlobalId = Guid.NewGuid().ToString();
46 | 
47 |             user.WhenCreated = DateTime.UtcNow;
48 | 
49 |             if (!(await DbContext.Users.AnyAsync()))
50 |             {
51 |                 // user.IsAdmin = true;
52 |                 user.Role = UserRole.Administrator;
53 |             }
54 | 
55 |            return await base.Add(user);
56 |         }
57 | 
58 |         public async Task<bool> MemberOf(string globalId, Models.User user)
59 |         {
60 |             if (user == null || string.IsNullOrEmpty(globalId))
61 |                 return false;
62 | 
63 |             if (user.IsAdmin)
64 |                 return true;
65 | 
66 |             bool result = false;
67 | 
68 |             var workspace = await DbContext.Workspaces
69 |                 .Include(t => t.Workers)
70 |                 .Where(t => t.GlobalId == globalId)
71 |                 .SingleOrDefaultAsync();
72 | 
73 |             result = workspace != null && workspace.CanEdit(user);
74 | 
75 |             if (result)
76 |                 workspace.LastActivity = DateTime.UtcNow;
77 | 
78 |             if (!result)
79 |             {
80 |                 var gamespace = await DbContext.Gamespaces
81 |                     .Include(g => g.Players)
82 |                     .Where(t => t.GlobalId == globalId)
83 |                     .SingleOrDefaultAsync();
84 | 
85 |                 result = gamespace != null & gamespace.CanEdit(user);
86 | 
87 |                 if (result)
88 |                     gamespace.LastActivity = DateTime.UtcNow;
89 |             }
90 | 
91 |             await DbContext.SaveChangesAsync();
92 | 
93 |             return result;
94 |         }
95 | 
96 |     }
97 | }
98 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Web/Data/Migrations/PostgreSQL/TopoMojoDb/20210218013150_ExpandTemplateLimits.cs:
--------------------------------------------------------------------------------
 1 | using Microsoft.EntityFrameworkCore.Migrations;
 2 | 
 3 | namespace TopoMojo.Web.Data.Migrations.PostgreSQL.TopoMojoDb
 4 | {
 5 |     public partial class ExpandTemplateLimits : Migration
 6 |     {
 7 |         protected override void Up(MigrationBuilder migrationBuilder)
 8 |         {
 9 |             migrationBuilder.AlterColumn<string>(
10 |                 name: "Challenge",
11 |                 table: "Workspaces",
12 |                 maxLength: 4096,
13 |                 nullable: true,
14 |                 oldClrType: typeof(string),
15 |                 oldType: "text",
16 |                 oldNullable: true);
17 | 
18 |             migrationBuilder.AlterColumn<string>(
19 |                 name: "Guestinfo",
20 |                 table: "Templates",
21 |                 maxLength: 1024,
22 |                 nullable: true,
23 |                 oldClrType: typeof(string),
24 |                 oldType: "character varying(255)",
25 |                 oldMaxLength: 255,
26 |                 oldNullable: true);
27 | 
28 |             migrationBuilder.AlterColumn<string>(
29 |                 name: "Detail",
30 |                 table: "Templates",
31 |                 maxLength: 4096,
32 |                 nullable: true,
33 |                 oldClrType: typeof(string),
34 |                 oldType: "character varying(2048)",
35 |                 oldMaxLength: 2048,
36 |                 oldNullable: true);
37 | 
38 |             migrationBuilder.AlterColumn<string>(
39 |                 name: "Challenge",
40 |                 table: "Gamespaces",
41 |                 maxLength: 4096,
42 |                 nullable: true,
43 |                 oldClrType: typeof(string),
44 |                 oldType: "text",
45 |                 oldNullable: true);
46 |         }
47 | 
48 |         protected override void Down(MigrationBuilder migrationBuilder)
49 |         {
50 |             migrationBuilder.AlterColumn<string>(
51 |                 name: "Challenge",
52 |                 table: "Workspaces",
53 |                 type: "text",
54 |                 nullable: true,
55 |                 oldClrType: typeof(string),
56 |                 oldMaxLength: 4096,
57 |                 oldNullable: true);
58 | 
59 |             migrationBuilder.AlterColumn<string>(
60 |                 name: "Guestinfo",
61 |                 table: "Templates",
62 |                 type: "character varying(255)",
63 |                 maxLength: 255,
64 |                 nullable: true,
65 |                 oldClrType: typeof(string),
66 |                 oldMaxLength: 1024,
67 |                 oldNullable: true);
68 | 
69 |             migrationBuilder.AlterColumn<string>(
70 |                 name: "Detail",
71 |                 table: "Templates",
72 |                 type: "character varying(2048)",
73 |                 maxLength: 2048,
74 |                 nullable: true,
75 |                 oldClrType: typeof(string),
76 |                 oldMaxLength: 4096,
77 |                 oldNullable: true);
78 | 
79 |             migrationBuilder.AlterColumn<string>(
80 |                 name: "Challenge",
81 |                 table: "Gamespaces",
82 |                 type: "text",
83 |                 nullable: true,
84 |                 oldClrType: typeof(string),
85 |                 oldMaxLength: 4096,
86 |                 oldNullable: true);
87 |         }
88 |     }
89 | }
90 | 


--------------------------------------------------------------------------------
/src/TopoMojo.vSphere/DatastorePath.cs:
--------------------------------------------------------------------------------
  1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
  2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
  3 | 
  4 | using System;
  5 | using System.Collections.Generic;
  6 | using System.Linq;
  7 | 
  8 | namespace TopoMojo.vSphere
  9 | {
 10 |     public class DatastorePath
 11 |     {
 12 |         public DatastorePath(string path)
 13 |         {
 14 |             Merge(path);
 15 |         }
 16 | 
 17 |         private string _ds;
 18 |         public string Datastore
 19 |         {
 20 |             get { return _ds;}
 21 |             set { _ds = value; }
 22 |         }
 23 | 
 24 |         private string _folder;
 25 |         public string FolderPath
 26 |         {
 27 |             get { return String.Format("[{0}] {1}", _ds, _folder).Trim(); }
 28 |             set { _folder = value; }
 29 |         }
 30 | 
 31 |         public string Folder
 32 |         {
 33 |             get { return _folder; }
 34 |             set { _folder = value; }
 35 |         }
 36 | 
 37 |         public string TopLevelFolder
 38 |         {
 39 |             get { return _folder.Split('/').First(); }
 40 |             set {
 41 |                 var list = new List<string>();
 42 |                 list.Add(value);
 43 |                 list.AddRange(_folder.Split('/').Skip(1));
 44 |                 _folder = string.Join("/", list);
 45 |             }
 46 |         }
 47 | 
 48 |         private string _file;
 49 |         public string File
 50 |         {
 51 |             get { return _file;}
 52 |             set { _file = value;}
 53 |         }
 54 | 
 55 |         /// <summary>
 56 |         /// Merge an "concrete" datastore root with an "abstract" datastore root
 57 |         /// </summary>
 58 |         /// <remarks>
 59 |         /// Templates have abstract paths: [ds] folder/disk.vmdk
 60 |         /// Here we merge with a concrete path: [actual] root/
 61 |         /// Result: [actual] root/folder/disk.vmdk
 62 |         /// </remarks>
 63 |         /// <param name="path"></param>
 64 |         public void Merge(string path)
 65 |         {
 66 |             if (!path.HasValue())
 67 |                 return;
 68 | 
 69 |             string file = "", ds = "", folder = "";
 70 | 
 71 |             folder = path.Replace("\\", "/");
 72 | 
 73 |             int x = folder.IndexOf("[");
 74 |             int y = folder.IndexOf("]");
 75 | 
 76 |             if (x >= 0 && y > x)
 77 |             {
 78 |                 ds = folder.Substring(x+1, y-x-1);
 79 |                 folder = folder.Substring(y+1).Trim();
 80 |             }
 81 | 
 82 |             x = folder.LastIndexOf('/');
 83 | 
 84 |             file = folder.Substring(x+1);
 85 | 
 86 |             folder = x >= 0
 87 |                 ? folder.Substring(0, x)
 88 |                 : "";
 89 | 
 90 |             if (Folder.HasValue() && folder.HasValue())
 91 |                 folder += "/";
 92 | 
 93 |             if (!_file.HasValue())
 94 |                 _file = file;
 95 | 
 96 |             Folder = folder + Folder;
 97 | 
 98 |             Datastore = ds;
 99 |         }
100 | 
101 |         public override string ToString()
102 |         {
103 |             string separator = FolderPath.EndsWith("]") ? " " : "/";
104 | 
105 |             return String.Format("{0}{1}{2}", FolderPath, separator, File);
106 |         }
107 |     }
108 | 
109 | }
110 | 


--------------------------------------------------------------------------------
/test/TopoMojo.Core.Tests/TemplateTests.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2019 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using TopoMojo;
 5 | using TopoMojo.Models;
 6 | using TopoMojo.Services;
 7 | using Xunit;
 8 | 
 9 | namespace Tests
10 | {
11 |     public class TemplateTests : CoreTest
12 |     {
13 |         [Fact]
14 |         public void CanCreateAndEditTemplates()
15 |         {
16 |             using (TestSession test = CreateSession())
17 |             {
18 |                 TemplateService mgr = test.GetTemplateManager();
19 |                 TemplateDetail template = mgr.Create(new TemplateDetail {
20 |                     Name = "JamOn",
21 |                     Detail = "original"
22 |                 }).Result;
23 | 
24 |                 Assert.True(template.Id > 0);
25 | 
26 |                 template.Name += "Changed";
27 |                 template.Detail = "detail";
28 |                 template = mgr.Configure(template).Result;
29 |                 Assert.Matches("Changed", template.Name);
30 |                 Assert.Equal("detail", template.Detail);
31 |             }
32 |         }
33 | 
34 |         [Fact]
35 |         public void ListReturnsList()
36 |         {
37 |             using (TestSession test = CreateSession())
38 |             {
39 |                 //test.AddActor("jam@this.ws");
40 |                 TemplateService mgr = test.GetTemplateManager();
41 |                 for (int i = 0; i < 5; i++)
42 |                 {
43 |                     TemplateDetail template = mgr.Create(new TemplateDetail {
44 |                         Name = "JamOn" + i.ToString(),
45 |                         Detail = i.ToString(),
46 |                         IsPublished = (i%2==0)
47 |                     }).Result;
48 |                 }
49 | 
50 |                 var list = mgr.List(new Search {
51 |                     Take = 50,
52 |                     //Term = "2",
53 |                     Filter = new string[] { "published" }
54 |                 }).Result;
55 |                 Assert.True(list.Length == 3);
56 |             }
57 |         }
58 | 
59 |         [Fact]
60 |         public void CanLinkTemplate()
61 |         {
62 |             using (TestSession test = CreateSession())
63 |             {
64 |                 //test.AddActor("jam@this.ws");
65 |                 WorkspaceService topoman = test.GetTopologyManager();
66 |                 Workspace topo = topoman.Create(new NewWorkspace{
67 |                     Name = "jamTopo"
68 |                 }).Result;
69 |                 TemplateService mgr = test.GetTemplateManager();
70 |                 for (int i = 1; i < 6; i++)
71 |                 {
72 |                     TemplateDetail template = mgr.Create(new TemplateDetail {
73 |                         Name = "JamOn" + i.ToString(),
74 |                         // Detail = "",
75 |                         IsPublished = (i%2==1)
76 |                     }).Result;
77 |                 }
78 | 
79 |                 Template t = mgr.Link(new TemplateLink { TemplateId = 5, WorkspaceId = topo.Id}).Result;
80 |                 t = mgr.Unlink(new TemplateLink { TemplateId = t.Id }).Result;
81 |                 var list = mgr.List(new Search {
82 |                     Take = 50,
83 |                     //Term = "2",
84 |                     Filter = new string[] {
85 |                         //"published"
86 |                     }
87 |                 }).Result;
88 |                 Assert.True(list.Length == 6);
89 |             }
90 |         }
91 |     }
92 | }
93 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Core/Services/UserService.cs:
--------------------------------------------------------------------------------
  1 | // Copyright 2020 Carnegie Mellon University.
  2 | // Released under a MIT (SEI) license. See LICENSE.md in the project root.
  3 | 
  4 | using System;
  5 | using System.Linq;
  6 | using System.Threading;
  7 | using System.Threading.Tasks;
  8 | using AutoMapper;
  9 | using Microsoft.EntityFrameworkCore;
 10 | using Microsoft.Extensions.Caching.Memory;
 11 | using Microsoft.Extensions.Logging;
 12 | using TopoMojo.Abstractions;
 13 | using TopoMojo.Data.Abstractions;
 14 | using TopoMojo.Extensions;
 15 | using TopoMojo.Models;
 16 | 
 17 | namespace TopoMojo.Services
 18 | {
 19 |     public class UserService: _Service
 20 |     {
 21 | 
 22 |         public UserService(
 23 |             IUserStore userStore,
 24 |             IMemoryCache userCache,
 25 |             ILogger<WorkspaceService> logger,
 26 |             IMapper mapper,
 27 |             CoreOptions options,
 28 |             IIdentityResolver identityResolver
 29 |         ) : base (logger, mapper, options, identityResolver)
 30 |         {
 31 |             _userStore = userStore;
 32 |             _userCache = userCache;
 33 |         }
 34 | 
 35 |         private readonly IUserStore _userStore;
 36 |         private readonly IMemoryCache _userCache;
 37 | 
 38 |         public async Task<User[]> List(Search search, CancellationToken ct = default(CancellationToken))
 39 |         {
 40 |             var q = _userStore.List(search.Term);
 41 | 
 42 |             if (search.Term.HasValue())
 43 |                 q = q.Where(p => p.Name.ToLower().Contains(search.Term.ToLower()));
 44 | 
 45 |             if (search.HasFilter("admins"))
 46 |                 q = q.Where(p => p.Role == UserRole.Administrator);
 47 | 
 48 |             q = q.OrderBy(p => p.Name);
 49 | 
 50 |             if (search.Skip > 0)
 51 |                 q = q.Skip(search.Skip);
 52 | 
 53 |             if (search.Take > 0)
 54 |                 q = q.Take(search.Take);
 55 | 
 56 |             return await Mapper.ProjectTo<User>(q).ToArrayAsync(ct);
 57 |         }
 58 | 
 59 |         public async Task<User> Load(string id)
 60 |         {
 61 |             if (string.IsNullOrEmpty(id))
 62 |                 return User;
 63 | 
 64 |             var user = await _userStore.Load(id);
 65 | 
 66 |             return (user != null)
 67 |                 ? Mapper.Map<User>(user)
 68 |                 : null;
 69 |         }
 70 | 
 71 |         public async Task<User> Add(User profile)
 72 |         {
 73 |             var entity = await _userStore.Add(
 74 |                 Mapper.Map<Data.User>(profile)
 75 |             );
 76 | 
 77 |             return Mapper.Map<User>(entity);
 78 |         }
 79 | 
 80 |         public async Task Update(User model)
 81 |         {
 82 |             var entity = await _userStore.Load(model.Id);
 83 | 
 84 |             entity.Name = model.Name;
 85 | 
 86 |             if (User.IsAdmin)
 87 |             {
 88 |                 entity.Role = model.Role;
 89 |                 entity.WorkspaceLimit = model.WorkspaceLimit;
 90 |             }
 91 | 
 92 |             await _userStore.Update(entity);
 93 |         }
 94 | 
 95 |         public async Task Delete(int id)
 96 |         {
 97 |             var entity = await _userStore.Load(id);
 98 | 
 99 |             if (entity == null || (!User.IsAdmin && User.Id != entity.Id))
100 |                 throw new InvalidOperationException();
101 | 
102 |             await _userStore.Delete(id);
103 |         }
104 | 
105 |         public async Task<bool> MemberOf(string globalId)
106 |         {
107 |             return await _userStore.MemberOf(globalId, User);
108 |         }
109 | 
110 |     }
111 | }
112 | 


--------------------------------------------------------------------------------
/src/TopoMojo.Core/Data/TopoMojoDbContext.cs:
--------------------------------------------------------------------------------
 1 | // Copyright 2020 Carnegie Mellon University. All Rights Reserved.
 2 | // Released under a 3 Clause BSD-style license. See LICENSE.md in the project root for license information.
 3 | 
 4 | using Microsoft.EntityFrameworkCore;
 5 | 
 6 | namespace TopoMojo.Data
 7 | {
 8 |     public class TopoMojoDbContext : DbContext
 9 |     {
10 |         public TopoMojoDbContext(DbContextOptions options)
11 |             : base(options)
12 |         {
13 |         }
14 | 
15 |         protected override void OnModelCreating(ModelBuilder builder)
16 |         {
17 |             base.OnModelCreating(builder);
18 | 
19 |             builder.Entity<Workspace>(b => {
20 |                 b.HasAlternateKey(t => t.GlobalId);
21 |                 b.Property(w => w.GlobalId).IsFixedLength().HasMaxLength(36);
22 |                 b.Property(w => w.Name).HasMaxLength(64);
23 |                 b.Property(w => w.Author).HasMaxLength(64);
24 |                 b.Property(w => w.Audience).HasMaxLength(64);
25 |                 b.Property(w => w.DocumentUrl).HasMaxLength(128);
26 |                 b.Property(w => w.Description).HasMaxLength(255);
27 |                 b.Property(w => w.Challenge).HasMaxLength(4096);
28 |             });
29 | 
30 |             builder.Entity<Gamespace>(b => {
31 |                 b.HasAlternateKey(t => t.GlobalId);
32 |                 b.Property(w => w.GlobalId).IsFixedLength().HasMaxLength(36);
33 |                 b.Property(w => w.Name).HasMaxLength(64);
34 |                 b.Property(w => w.Audience).HasMaxLength(64);
35 |                 b.Property(w => w.Challenge).HasMaxLength(4096);
36 |             });
37 | 
38 |             builder.Entity<Template>(b => {
39 |                 b.HasAlternateKey(t => t.GlobalId);
40 |                 b.Property(w => w.GlobalId).IsFixedLength().HasMaxLength(36);
41 |                 b.Property(w => w.Name).HasMaxLength(64);
42 |                 b.Property(w => w.Description).HasMaxLength(255);
43 |                 b.Property(w => w.Guestinfo).HasMaxLength(1024);
44 |                 b.Property(w => w.Networks).HasMaxLength(64);
45 |                 b.Property(w => w.Detail).HasMaxLength(4096);
46 |             });
47 | 
48 |             builder.Entity<User>(b => {
49 |                 b.HasAlternateKey(t => t.GlobalId);
50 |                 b.Property(w => w.GlobalId).IsFixedLength().HasMaxLength(36);
51 |                 b.Property(w => w.Name).HasMaxLength(64);
52 |             });
53 | 
54 |             builder.Entity<Message>(b => {
55 |                 b.HasIndex(t => t.RoomId);
56 |                 b.Property(w => w.RoomId).IsFixedLength().HasMaxLength(36);
57 |                 b.Property(w => w.AuthorName).HasMaxLength(64);
58 |                 b.Property(w => w.Text).HasMaxLength(2048);
59 |             });
60 |         }
61 | 
62 |         public DbSet<Workspace> Workspaces { get; set; }
63 |         public DbSet<Template> Templates { get; set; }
64 |         public DbSet<Gamespace> Gamespaces { get; set; }
65 |         public DbSet<User> Users { get; set; }
66 |         public DbSet<Worker> Workers { get; set; }
67 |         public DbSet<Player> Players { get; set; }
68 |         public DbSet<Message> Messages { get; set; }
69 |         public DbSet<Activity> History { get; set; }
70 |     }
71 | 
72 |     public class TopoMojoDbContextPostgreSQL: TopoMojoDbContext
73 |     {
74 |         public TopoMojoDbContextPostgreSQL(DbContextOptions<TopoMojoDbContextPostgreSQL> options) : base(options) {}
75 |     }
76 | 
77 |     public class TopoMojoDbContextSqlServer: TopoMojoDbContext
78 |     {
79 |         public TopoMojoDbContextSqlServer(DbContextOptions<TopoMojoDbContextSqlServer> options) : base(options) {}
80 |     }
81 | 
82 |     public class TopoMojoDbContextInMemory: TopoMojoDbContext
83 |     {
84 |         public TopoMojoDbContextInMemory(DbContextOptions<TopoMojoDbContextInMemory> options) : base(options) {}
85 |     }
86 | }
87 | 


--------------------------------------------------------------------------------