) -> Bool {
47 | return lhs.hashValue == rhs.hashValue
48 | }
49 |
50 | }
51 |
--------------------------------------------------------------------------------
/Sources/App/Supporting Files/EmailTemplates.swift:
--------------------------------------------------------------------------------
1 | //
2 | // PasswordResetEmail.swift
3 | // App
4 | //
5 | // Created by Nathan Tannar on 2018-08-20.
6 | //
7 |
8 | import Vapor
9 | import SendGrid
10 |
11 | public struct EmailTemplates {
12 |
13 | static func passwordReset(to: EmailAddress, token: String) -> SendGridEmail {
14 |
15 | let from = EmailAddress(email: Environment.NO_REPLY_EMAIL, name: Environment.APP_NAME)
16 | let personalization = Personalization(to: [to])
17 |
18 | let header = "Password Reset for \(Environment.APP_NAME)"
19 | let link = "http://\(Environment.PUBLIC_URL)/auth/reset/password/\(token)"
20 |
21 | let html = "\(header)
To reset your password, please visit this link
This link expires in 48 hours."
22 | let text = header + "\nTo reset your password, please visit " + link + "\n This link expires in 48 hours."
23 |
24 | return SendGridEmail(personalizations: [personalization], from: from, replyTo: from, subject: "Password Reset", content: [["type":"text/plain", "value": text], ["type":"text/html", "value": html]], sendAt: Date())
25 | }
26 |
27 | static func accountVerification(to: EmailAddress, token: String) -> SendGridEmail {
28 |
29 | let from = EmailAddress(email: Environment.NO_REPLY_EMAIL, name: Environment.APP_NAME)
30 | let personalization = Personalization(to: [to])
31 |
32 | let header = "Welcome To \(Environment.APP_NAME)"
33 | let link = "http://\(Environment.PUBLIC_URL)/auth/verify/email/\(token)"
34 |
35 | let html = "\(header)
Please verify your email by visiting this link
This link expires in 48 hours."
36 | let text = header + "\nPlease verify your email by visiting " + link + "\n This link expires in 48 hours."
37 |
38 | return SendGridEmail(personalizations: [personalization], from: from, replyTo: from, subject: "Email Verification", content: [["type":"text/plain", "value": text], ["type":"text/html", "value": html]], sendAt: Date())
39 | }
40 |
41 | }
42 |
--------------------------------------------------------------------------------
/Sources/App/app.swift:
--------------------------------------------------------------------------------
1 | import Vapor
2 |
3 | /// Creates an instance of Application. This is called from main.swift in the run target.
4 | public func app(_ env: Environment) throws -> Application {
5 | var config = Config.default()
6 | var env = env
7 | var services = Services.default()
8 | try configure(&config, &env, &services)
9 | let app = try Application(config: config, environment: env, services: services)
10 | try boot(app)
11 | return app
12 | }
13 |
--------------------------------------------------------------------------------
/Sources/App/boot.swift:
--------------------------------------------------------------------------------
1 | import Vapor
2 |
3 | /// Called after your application has initialized.
4 | public func boot(_ app: Application) throws {
5 |
6 | try jobs(app)
7 |
8 | }
9 |
--------------------------------------------------------------------------------
/Sources/App/configure.swift:
--------------------------------------------------------------------------------
1 | import Vapor
2 | import FluentMySQL
3 | import Authentication
4 | import SendGrid
5 | import Leaf
6 |
7 | /// Called before your application initializes.
8 | public func configure(
9 | _ config: inout Config,
10 | _ env: inout Environment,
11 | _ services: inout Services
12 | ) throws {
13 |
14 | // Router
15 | let router = EngineRouter.default()
16 | try routes(router)
17 | services.register(router, as: Router.self)
18 |
19 | // Server
20 | let server = NIOServerConfig.default(port: Environment.PORT)
21 | services.register(server)
22 |
23 | // Web Sockets
24 | let wss = NIOWebSocketServer.default()
25 | try sockets(wss)
26 | services.register(wss, as: WebSocketServer.self)
27 |
28 | // Fluent Coommands
29 | var commandConfig = CommandConfig.default()
30 | commandConfig.useFluentCommands()
31 | services.register(commandConfig)
32 |
33 | // MySQL Database
34 | try services.register(FluentMySQLProvider())
35 | let mysqlConfig = MySQLDatabaseConfig(
36 | hostname: Environment.DATABASE_HOSTNAME,
37 | port: Environment.DATABASE_PORT,
38 | username: Environment.DATABASE_USER,
39 | password: Environment.DATABASE_PASSWORD,
40 | database: Environment.DATABASE_DB
41 | // characterSet: .utf8_general_ci,
42 | // transport: .unverifiedTLS
43 | )
44 | services.register(mysqlConfig)
45 |
46 | // APNS
47 | services.register(APNS.self)
48 |
49 | // Shell
50 | services.register(Shell.self)
51 |
52 | // Leaf Rendering
53 | try services.register(LeafProvider())
54 | config.prefer(LeafRenderer.self, for: ViewRenderer.self)
55 |
56 | // Middleware
57 | var middlewares = MiddlewareConfig.default()
58 |
59 | // Public Files
60 | middlewares.use(FileMiddleware.self)
61 |
62 | // Route Logging
63 | services.register(RouteLoggingMiddleware.self)
64 | middlewares.use(RouteLoggingMiddleware.self)
65 |
66 | // Error Logging
67 | services.register(ErrorLoggingMiddleware.self)
68 | middlewares.use(ErrorLoggingMiddleware.self)
69 |
70 | // Auth
71 | try services.register(AuthenticationProvider())
72 | middlewares.use(SessionsMiddleware.self)
73 |
74 | // Cache
75 | var dbsConfig = DatabasesConfig()
76 | dbsConfig.add(database: MySQLDatabase(config: mysqlConfig), as: .mysql)
77 | dbsConfig.enableLogging(on: .mysql)
78 | services.register(dbsConfig)
79 | config.prefer(MemoryKeyedCache.self, for: KeyedCache.self)
80 |
81 | // Secret
82 | services.register(SecretMiddleware.self)
83 |
84 | // Register all the middleware
85 | services.register(middlewares)
86 |
87 | // SendGrid Email
88 | if let SENDGRID_API_KEY = Environment.SENDGRID_API_KEY {
89 | let config = SendGridConfig(apiKey: SENDGRID_API_KEY)
90 | services.register(config)
91 | try services.register(SendGridProvider())
92 | }
93 |
94 | // Migrations
95 | var migrations = MigrationConfig()
96 | migrations.add(model: FileRecord.self, database: .mysql)
97 | migrations.add(model: User.self, database: .mysql)
98 | migrations.add(model: Installation.self, database: .mysql)
99 | migrations.add(model: PushRecord.self, database: .mysql)
100 | migrations.add(model: BearerToken.self, database: .mysql)
101 | migrations.add(model: VerifyToken.self, database: .mysql)
102 | migrations.add(model: RemoteConfig.self, database: .mysql)
103 | migrations.add(model: Conversation.self, database: .mysql)
104 | migrations.add(model: ConversationUser.self, database: .mysql)
105 | migrations.add(model: Message.self, database: .mysql)
106 | services.register(migrations)
107 | }
108 |
--------------------------------------------------------------------------------
/Sources/App/jobs.swift:
--------------------------------------------------------------------------------
1 | import Vapor
2 | import Schedule
3 |
4 | /// Register your application's scheduled jobs here.
5 | public func jobs(_ app: Application) throws {
6 |
7 | Schedule.every(.sunday, .monday, .tuesday, .wednesday, .thursday, .friday, .saturday).at("21:00").do {
8 | // Do some nightly task at 9pm
9 | }
10 | }
11 |
--------------------------------------------------------------------------------
/Sources/App/routes.swift:
--------------------------------------------------------------------------------
1 | import Vapor
2 | import FluentMySQL
3 |
4 | /// Register your application's routes here.
5 | public func routes(_ router: Router) throws {
6 |
7 | router.get { req throws -> Future in
8 | return Future.map(on: req) {
9 | ServerStatus(status: "Online", message: "Welcome to the Phoenix API")
10 | }
11 | }
12 |
13 | let authController = AuthController()
14 | try router.register(collection: authController)
15 |
16 | let userController = UserController()
17 | try router.register(collection: userController)
18 |
19 | let pushController = PushController()
20 | try router.register(collection: pushController)
21 |
22 | let remoteConfigController = RemoteConfigController()
23 | try router.register(collection: remoteConfigController)
24 |
25 | let installationController = InstallationController()
26 | try router.register(collection: installationController)
27 |
28 | let conversationController = ConversationController()
29 | try router.register(collection: conversationController)
30 |
31 | let fileController = FileController()
32 | try router.register(collection: fileController)
33 |
34 | }
35 |
--------------------------------------------------------------------------------
/Sources/App/sockets.swift:
--------------------------------------------------------------------------------
1 | import Vapor
2 |
3 | /// Register your application's socket routes here.
4 | public func sockets(_ wss: NIOWebSocketServer) throws {
5 |
6 | let conversationSocketController = ConversationSocketController()
7 | try wss.register(collection: conversationSocketController)
8 |
9 | }
10 |
--------------------------------------------------------------------------------
/Sources/Run/main.swift:
--------------------------------------------------------------------------------
1 | import App
2 |
3 | try app(.detect()).run()
4 |
--------------------------------------------------------------------------------
/Tests/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nathantannar4/the.phoenix.project/2a9f2e2d3d1021e46ba9c398857c908b344ebff3/Tests/.gitkeep
--------------------------------------------------------------------------------
/Tests/AppTests/API.swift:
--------------------------------------------------------------------------------
1 | //
2 | // API.swift
3 | // PhoenixClientExample
4 | //
5 | // Created by Nathan Tannar on 2018-08-20.
6 | // Copyright © 2018 Nathan Tannar. All rights reserved.
7 | //
8 |
9 | import Foundation
10 | import Result
11 | import Moya
12 | import Promises
13 | @testable import App
14 |
15 | enum API {
16 |
17 | case ping
18 |
19 | case signUp(User)
20 |
21 | case login(User)
22 |
23 | case logout
24 |
25 | case verifyLogin
26 |
27 |
28 | }
29 |
30 | extension API: TargetType {
31 |
32 | var baseURL: URL { return URL(string: "http://localhost:8000")! }
33 |
34 | var path: String {
35 | switch self {
36 | case .ping:
37 | return "/"
38 | case .signUp:
39 | return "/auth/register"
40 | case .login:
41 | return "/auth/login"
42 | case .verifyLogin:
43 | return "/auth/verify/login"
44 | case .logout:
45 | return "/auth/logout"
46 | }
47 | }
48 |
49 | var method: Moya.Method {
50 | switch self {
51 | case .ping, .verifyLogin:
52 | return .get
53 | case .signUp, .login, .logout:
54 | return .post
55 | }
56 | }
57 |
58 | var sampleData: Data {
59 | return Data()
60 | }
61 |
62 | static var bearerToken: String?
63 |
64 | var headers: [String : String]? {
65 | return ["X-API-KEY": "myApiKey", "Content-Type": "application/json", "Accept": "application/json"]
66 | }
67 |
68 | var validationType: ValidationType {
69 | return .none
70 | }
71 |
72 | var task: Task {
73 | switch self {
74 | case .ping, .verifyLogin, .logout:
75 | return .requestPlain
76 | case .signUp(let auth):
77 | return .requestJSONEncodable(auth)
78 | case .login(let auth):
79 | return .requestJSONEncodable(auth)
80 | }
81 | }
82 |
83 | }
84 |
85 | extension API: AccessTokenAuthorizable {
86 |
87 | var authorizationType: AuthorizationType {
88 | switch self {
89 | case .login:
90 | return .basic
91 | case .verifyLogin, .logout:
92 | return .bearer
93 | default:
94 | return .none
95 | }
96 | }
97 |
98 | }
99 |
100 | final class AuthPlugin: PluginType {
101 |
102 | static var bearerToken: String?
103 |
104 | func prepare(_ request: URLRequest, target: TargetType) -> URLRequest {
105 |
106 | guard let route = target as? API else { return request }
107 |
108 | let authorizationType = route.authorizationType
109 |
110 | var request = request
111 |
112 | switch route.authorizationType {
113 | case .basic:
114 | switch route {
115 | case .login(let auth):
116 | let str = "\(auth.username):\(auth.password)"
117 | let encoded = str.data(using: .utf8)?.base64EncodedString()
118 | guard let basic = encoded else { return request }
119 | let authValue = authorizationType.rawValue + " " + basic
120 | request.setValue(authValue, forHTTPHeaderField: "Authorization")
121 | default:
122 | break
123 | }
124 | case .bearer:
125 | guard let token = AuthPlugin.bearerToken else { return request }
126 | let authValue = authorizationType.rawValue + " " + token
127 | request.setValue(authValue, forHTTPHeaderField: "Authorization")
128 | case .none:
129 | break
130 | }
131 |
132 | return request
133 |
134 | }
135 |
136 | func didReceive(_ result: Result, target: TargetType) {
137 |
138 | guard let route = target as? API else { return }
139 |
140 | switch route {
141 | case .login:
142 | do {
143 | let response = try result.dematerialize()
144 | let decoder = JSONDecoder()
145 | if #available(OSX 10.12, *) {
146 | decoder.dateDecodingStrategy = .iso8601
147 | } else {
148 | fatalError("`dateDecodingStrategy` Unavailable")
149 | }
150 | let token = try response.map(BearerToken.self, using: decoder)
151 | AuthPlugin.bearerToken = token.value
152 | } catch {
153 | // Login must have failed
154 | }
155 | case .logout:
156 | do {
157 | let response = try result.dematerialize()
158 | if response.statusCode == 200 {
159 | AuthPlugin.bearerToken = nil
160 | }
161 | } catch {
162 | // Some logout must have occurred
163 | }
164 | default:
165 | break
166 | }
167 |
168 | }
169 |
170 | }
171 |
172 | final class Network {
173 |
174 | private static var provider: MoyaProvider {
175 | return MoyaProvider(plugins: [NetworkLoggerPlugin(verbose: true), AuthPlugin()])
176 | }
177 |
178 | static func request(_ route: API,
179 | decodeAs decodable: T.Type) -> Promise {
180 | return Promise(on: .global(qos: .background)) { fufill, reject in
181 | provider.request(route) { result in
182 | switch result {
183 | case .success(let response):
184 | do {
185 | let decoder = JSONDecoder()
186 | if #available(OSX 10.12, *) {
187 | decoder.dateDecodingStrategy = .iso8601
188 | } else {
189 | fatalError("`dateDecodingStrategy` Unavailable")
190 | }
191 | let model = try response.filterSuccessfulStatusCodes()
192 | .map(decodable, using: decoder)
193 | fufill(model)
194 | } catch {
195 | reject(error)
196 | }
197 | case .failure(let error):
198 | reject(error)
199 | }
200 | }
201 | }
202 | }
203 |
204 | static func request(_ route: API) -> Promise {
205 | return Promise(on: .global(qos: .background)) { fufill, reject in
206 | provider.request(route) { result in
207 | switch result {
208 | case .success(let response):
209 | do {
210 | _ = try response.filterSuccessfulStatusCodes()
211 | fufill(response.data)
212 | } catch {
213 | reject(error)
214 | }
215 | case .failure(let error):
216 | reject(error)
217 | }
218 | }
219 | }
220 | }
221 |
222 | }
223 |
--------------------------------------------------------------------------------
/Tests/AppTests/AppTestCase.swift:
--------------------------------------------------------------------------------
1 | import Vapor
2 | @testable import App
3 | import FluentMySQL
4 | import XCTest
5 |
6 | class AppTestCase: XCTestCase {
7 |
8 | var app: Application!
9 |
10 | override func setUp() {
11 | super.setUp()
12 |
13 | // try! Application.reset()
14 | app = try! Application.testable()
15 | }
16 |
17 | override func tearDown() {
18 | super.tearDown()
19 | }
20 |
21 | }
22 |
--------------------------------------------------------------------------------
/Tests/AppTests/Application+Testable.swift:
--------------------------------------------------------------------------------
1 | import Vapor
2 | @testable import App
3 |
4 | extension Application {
5 |
6 | static func testable(envArgs: [String]? = nil) throws -> Application {
7 | var config = Config.default()
8 | var services = Services.default()
9 | var env = Environment.testing
10 |
11 | if let environmentArgs = envArgs {
12 | env.arguments = environmentArgs
13 | }
14 |
15 | try App.configure(&config, &env, &services)
16 | let app = try Application(config: config, environment: env, services: services)
17 |
18 | try App.boot(app)
19 | return app
20 | }
21 |
22 | static func reset() throws {
23 | let revertEnvironment = ["vapor", "revert", "--all", "-y"]
24 | try Application.testable(envArgs: revertEnvironment).asyncRun().wait()
25 | let migrateEnvironment = ["vapor", "migrate", "-y"]
26 | try Application.testable(envArgs: migrateEnvironment).asyncRun().wait()
27 | }
28 |
29 | }
30 |
--------------------------------------------------------------------------------
/Tests/AppTests/Auth+Tests.swift:
--------------------------------------------------------------------------------
1 | import App
2 | import Vapor
3 | import Promises
4 | import Moya
5 | import XCTest
6 |
7 | final class AuthTests: AppTestCase {
8 |
9 | // MARK: Linux
10 |
11 | static let allTests = [
12 | ("testRegister", testRegister),
13 | ("testLogin", testLogin)
14 | ]
15 |
16 | // MARK: - Tests
17 |
18 | func testRegister() {
19 |
20 | let expectation = XCTestExpectation(description: "testRegister")
21 |
22 | let user = try! User(username: String.randomAlphanumeric(ofLength: 10),
23 | password: String.randomAlphanumeric(ofLength: 10))
24 |
25 | Network.request(.signUp(user), decodeAs: User.Public.self)
26 | .then { user in
27 | XCTAssert(user.id != nil)
28 | }.catch { error in
29 | XCTAssert(false, error.localizedDescription)
30 | }.always {
31 | expectation.fulfill()
32 | }
33 |
34 | wait(for: [expectation], timeout: 10.0)
35 | }
36 |
37 | func testLogin() {
38 |
39 | let expectation = XCTestExpectation(description: "testLogin")
40 |
41 | let user = try! User(username: String.randomAlphanumeric(ofLength: 10),
42 | password: String.randomAlphanumeric(ofLength: 10))
43 |
44 | Network.request(.signUp(user))
45 | .then { _ in
46 | Network.request(.login(user), decodeAs: BearerToken.Public.self)
47 | }.then { token in
48 | XCTAssert(token.expiresAt != nil)
49 | }.catch { error in
50 | XCTAssert(false, error.localizedDescription)
51 | }.always {
52 | expectation.fulfill()
53 | }
54 |
55 | wait(for: [expectation], timeout: 10.0)
56 | }
57 |
58 | func testVerifyLogin() {
59 |
60 | let expectation = XCTestExpectation(description: "testVerifyLogin")
61 |
62 | let user = try! User(username: String.randomAlphanumeric(ofLength: 10),
63 | password: String.randomAlphanumeric(ofLength: 10))
64 |
65 | Network.request(.signUp(user))
66 | .then { _ in
67 | Network.request(.login(user), decodeAs: BearerToken.Public.self)
68 | }.then { _ in
69 | Network.request(.verifyLogin, decodeAs: User.Public.self)
70 | }.then { authUser in
71 | XCTAssert(authUser.id != nil)
72 | XCTAssert(authUser.username == user.username)
73 | }.catch { error in
74 | XCTAssert(false, error.localizedDescription)
75 | }.always {
76 | expectation.fulfill()
77 | }
78 |
79 | wait(for: [expectation], timeout: 10.0)
80 | }
81 |
82 | func testLogout() {
83 |
84 | let expectation = XCTestExpectation(description: "testLogout")
85 |
86 | let user = try! User(username: String.randomAlphanumeric(ofLength: 10),
87 | password: String.randomAlphanumeric(ofLength: 10))
88 |
89 | Network.request(.signUp(user))
90 | .then { _ in
91 | Network.request(.login(user), decodeAs: BearerToken.Public.self)
92 | }.then { _ in
93 | Network.request(.logout)
94 | }.catch { error in
95 | XCTAssert(false, error.localizedDescription)
96 | }.always {
97 | XCTAssert(AuthPlugin.bearerToken == nil, "Auth Plugin didn't reset")
98 | expectation.fulfill()
99 | }
100 |
101 | wait(for: [expectation], timeout: 10.0)
102 | }
103 |
104 | }
105 |
--------------------------------------------------------------------------------
/Tests/LinuxMain.swift:
--------------------------------------------------------------------------------
1 | import XCTest
2 |
3 | @testable import AppTests
4 |
5 | XCTMain([
6 | testCase(UserTests.allTests)
7 | ])
8 |
--------------------------------------------------------------------------------
/circle.yml:
--------------------------------------------------------------------------------
1 | version: 2
2 |
3 | jobs:
4 | macos:
5 | macos:
6 | xcode: "9.2"
7 | steps:
8 | - checkout
9 | - run: swift build
10 | - run: swift test
11 | linux:
12 | docker:
13 | - image: norionomura/swift:swift-4.1-branch
14 | steps:
15 | - checkout
16 | - run: apt-get update
17 | - run: apt-get install -yq libssl-dev
18 | - run: swift build
19 | - run: swift test
20 | workflows:
21 | version: 2
22 | tests:
23 | jobs:
24 | - linux
25 | # - macos
26 |
--------------------------------------------------------------------------------
/cloud.yml:
--------------------------------------------------------------------------------
1 | type: "vapor"
2 | swift_version: "4.1.0"
3 | run_parameters: "serve --port 8080 --hostname 0.0.0.0"
4 |
--------------------------------------------------------------------------------
/config/deploy.rb:
--------------------------------------------------------------------------------
1 | # config valid for current version and patch releases of Capistrano
2 | lock "~> 3.11.0"
3 |
4 | set :application, "application_name"
5 | set :repo_url, "https://github.com/username/repo.git"
6 |
7 | # Default branch is :master
8 | # ask :branch, `git rev-parse --abbrev-ref HEAD`.chomp
9 |
10 | # Default deploy_to directory is /var/www/my_app_name
11 | set :deploy_to, "/var/www/application_name"
12 |
13 | # Default value for :format is :airbrussh.
14 | # set :format, :airbrussh
15 |
16 | # You can configure the Airbrussh format using :format_options.
17 | # These are the defaults.
18 | # set :format_options, command_output: true, log_file: "log/capistrano.log", color: :auto, truncate: :auto
19 |
20 | # Default value for :pty is false
21 | # set :pty, true
22 |
23 | # Default value for :linked_files is []
24 | # append :linked_files, "config/database.yml"
25 |
26 | # Default value for linked_dirs is []
27 | # append :linked_dirs, "log", "tmp/pids", "tmp/cache", "tmp/sockets", "public/system"
28 |
29 | # Default value for default_env is {}
30 | # set :default_env, { path: "/opt/ruby/bin:$PATH" }
31 |
32 | # Default value for local_user is ENV['USER']
33 | # set :local_user, -> { `git config user.name`.chomp }
34 |
35 | # Default value for keep_releases is 5
36 | # set :keep_releases, 5
37 |
38 | # Uncomment the following to require manually verifying the host key before first deploy.
39 | # set :ssh_options, verify_host_key: :secure
40 |
41 | namespace :deploy do
42 |
43 | desc "Push local changes to Git repository"
44 | task :push do
45 |
46 | # Check for any local changes that haven't been committed
47 | # Use 'cap deploy:push IGNORE_DEPLOY_RB=1' to ignore changes to this file (for testing)
48 | status = %x(git status --porcelain).chomp
49 | if status != ""
50 | puts "Local git repository has uncommitted changes"
51 | set :commit_message, ask("Commit Message (or input skip to skip)", Time.now.strftime("%d/%m/%Y %H:%M"))
52 | if fetch(:commit_message) != 'skip'
53 | run_locally do
54 | execute "git add -A"
55 | execute "git commit -m '#{fetch(:commit_message)}'"
56 | end
57 | end
58 | end
59 |
60 | # Check we are on the master branch, so we can't forget to merge before deploying
61 | branch = %x(git branch --no-color 2>/dev/null | sed -e '/^[^*]/d' -e 's/* \\(.*\\)/\\1/').chomp
62 | if branch != "master" && !ENV["IGNORE_BRANCH"]
63 | raise "Not on master branch (set IGNORE_BRANCH=1 to ignore)"
64 | end
65 |
66 | # Push the changes
67 | if ! system "git push #{fetch(:repo_url)} master"
68 | raise "Failed to push changes to #{fetch(:repo_url)}"
69 | end
70 |
71 | end
72 |
73 | if !ENV["NO_PUSH"]
74 | before "deploy", "deploy:push"
75 | end
76 |
77 | # This method changes to our latest deploy directory and fetches the dependencies using the Vapor Toolbox
78 | desc 'Fetch Dependencies'
79 | task :dependencies do
80 | on roles(:app) do
81 | execute("cd #{fetch(:deploy_to)}/current && vapor fetch --verbose")
82 | end
83 | end
84 |
85 | # This method changes to our latest deploy directory and builds our app using the release configuration using the Vapor Toolbox
86 | desc 'Build Vapor App'
87 | task :build do
88 | on roles(:app) do
89 | execute("cd #{fetch(:deploy_to)}/current && vapor build --release --verbose")
90 | end
91 | end
92 |
93 | after :publishing, 'deploy:dependencies'
94 | after :publishing, 'deploy:build'
95 |
96 |
97 | desc 'Start Vapor App'
98 | task :start do
99 | on roles(:app) do
100 | execute(:sudo, 'systemctl', :start, :application)
101 | end
102 | end
103 |
104 | desc 'Stop Vapor App'
105 | task :stop do
106 | on roles(:app) do
107 | execute(:sudo, 'systemctl', :stop, :application)
108 | end
109 | end
110 |
111 | desc 'Restart Vapor App'
112 | task :restart do
113 | on roles(:app) do
114 | execute(:sudo, 'systemctl', :restart, :application)
115 | end
116 | end
117 |
118 | # Add this line below after :publishing, 'deploy:build'
119 | after :publishing, 'deploy:restart'
120 |
121 | end
122 |
--------------------------------------------------------------------------------
/config/deploy/production.rb:
--------------------------------------------------------------------------------
1 | # server-based syntax
2 | # ======================
3 | # Defines a single server with a list of roles and multiple properties.
4 | # You can define all roles on a single server, or split them:
5 |
6 | server "IP_ADDRESS", user: "USERNAME", roles: %w{app db web}, my_property: :my_value
7 | # server "example.com", user: "deploy", roles: %w{app web}, other_property: :other_value
8 | # server "db.example.com", user: "deploy", roles: %w{db}
9 |
10 |
11 |
12 | # role-based syntax
13 | # ==================
14 |
15 | # Defines a role with one or multiple servers. The primary server in each
16 | # group is considered to be the first unless any hosts have the primary
17 | # property set. Specify the username and a domain or IP for the server.
18 | # Don't use `:all`, it's a meta role.
19 |
20 | # role :app, %w{deploy@example.com}, my_property: :my_value
21 | # role :web, %w{user1@primary.com user2@additional.com}, other_property: :other_value
22 | # role :db, %w{deploy@example.com}
23 |
24 |
25 |
26 | # Configuration
27 | # =============
28 | # You can set any configuration variable like in config/deploy.rb
29 | # These variables are then only loaded and set in this stage.
30 | # For available Capistrano configuration variables see the documentation page.
31 | # http://capistranorb.com/documentation/getting-started/configuration/
32 | # Feel free to add new variables to customise your setup.
33 |
34 |
35 |
36 | # Custom SSH Options
37 | # ==================
38 | # You may pass any option but keep in mind that net/ssh understands a
39 | # limited set of options, consult the Net::SSH documentation.
40 | # http://net-ssh.github.io/net-ssh/classes/Net/SSH.html#method-c-start
41 | #
42 | # Global options
43 | # --------------
44 | # set :ssh_options, {
45 | # keys: %w(/home/rlisowski/.ssh/id_rsa),
46 | # forward_agent: false,
47 | # auth_methods: %w(password)
48 | # }
49 | #
50 | # The server-based syntax can be used to override options:
51 | # ------------------------------------
52 | # server "example.com",
53 | # user: "user_name",
54 | # roles: %w{web app},
55 | # ssh_options: {
56 | # user: "user_name", # overrides user setting above
57 | # keys: %w(/home/user_name/.ssh/id_rsa),
58 | # forward_agent: false,
59 | # auth_methods: %w(publickey password)
60 | # # password: "please use keys"
61 | # }
62 |
--------------------------------------------------------------------------------
/docker-compose.yml:
--------------------------------------------------------------------------------
1 | version: '3'
2 | services:
3 | til-app:
4 | depends_on:
5 | - postgres
6 | build: .
7 | environment:
8 | - DATABASE_HOSTNAME=postgres
9 | - DATABASE_PORT=5432
10 | postgres:
11 | image: "postgres"
12 | environment:
13 | - POSTGRES_DB=vapor-test
14 | - POSTGRES_USER=vapor
15 | - POSTGRES_PASSWORD=password
16 |
--------------------------------------------------------------------------------
2 |
3 | # The Phoenix Project
4 |
5 | > A deployment ready template with support for authentication, real-time chat, push notifications, files, email verification
6 |
7 | ### phoe·nix
8 |
9 | *noun*
10 |
11 | > (in classical mythology) A unique bird that lived for five or six centuries in the Arabian desert, after this time burning itself on a funeral pyre and rising from the ashes with renewed youth to live through another cycle.
12 |
13 | **Goal**: To establish an advanced template that lays the groundwork for common mobile app API functionality such as authentication, real-time chat and push notifications.
14 |
15 | ## Why Vapor?
16 |
17 | "Server-side app development with Swift and Vapor is a unique experience. In contrast to many traditional server-side languages — for example PHP, JavaScript, Ruby — Swift is strongly- and statically-typed. This characteristic has greatly reduced the number of runtime crashes in iOS apps and your server-side apps will also enjoy this benefit.
18 |
19 | Another potential benefit of server-side Swift is improved performance. Because Swift is a compiled language, apps written using Swift are likely to perform better than those written in an interpreted language.
20 |
21 | > Excerpt From: By Tim Condon. "Server Side Swift with Vapor."
22 |
23 | If you are unfamiliar with Vapor 3 please first see their [Getting Started Guide](https://docs.vapor.codes/3.0/)
24 |
25 | ## Requirements
26 |
27 | - Swift 4.1
28 | - Vapor 3
29 | - Vapor Toolbox
30 | - cURL (for Push Notifications)
31 | - MySQL (other DBs are supported you will just have to modify the template)
32 |
33 | ## Build
34 |
35 | ```
36 | vapor fetch
37 | vapor build
38 | ```
39 |
40 | ## Run
41 |
42 | ```
43 | vapor run
44 | ```
45 |
46 | ## Environment Variables
47 |
48 | Default environment variables can be set in `Sources/App/Extensions/Environment+Extensions.swift`. Note, some do not have defaults so you will need to set them in your environment or docker container.
49 |
50 | ```
51 |