osctrl/Makefile at develop · jmpsec/osctrl · GitHub

History

369 lines (290 loc) · 9.8 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

export GO111MODULE=on

export GOPROXY=https://proxy.golang.org,direct

SHELL := /bin/bash

TLS_DIR = cmd/tls

TLS_NAME = osctrl-tls

TLS_CODE = ${TLS_DIR:=/*.go}

FRONTEND_DIR = frontend

FRONTEND_NAME = osctrl-frontend

API_DIR = cmd/api

API_NAME = osctrl-api

API_CODE = ${API_DIR:=/*.go}

CLI_DIR = cmd/cli

CLI_NAME = osctrl-cli

CLI_CODE = ${CLI_DIR:=/*.go}

MCP_DIR = cmd/mcp

MCP_NAME = osctrl-mcp

MCP_CODE = ${MCP_DIR:=/*.go}

DEST ?= /opt/osctrl

OUTPUT = bin

DIST = dist

STATIC_ARGS = -ldflags "-linkmode external -extldflags -static"

BUILD_ARGS = -ldflags "-s -w -X main.buildCommit=$(shell git rev-parse HEAD) -X main.buildDate=$(shell date -u +%Y-%m-%dT%H:%M:%SZ)"

SWAG_VERSION ?= v1.16.6

SWAG = go run github.com/swaggo/swag/cmd/swag@$(SWAG_VERSION)

SWAG_OUTPUT_DIR ?= $(API_DIR)/docs

.PHONY: build static clean tls cli api mcp mcp-static swagger openapi openapi-check release release-build release-check release-init clean-dist frontend frontend-install frontend-dev frontend-build frontend-test

# Build code according to caller OS and architecture

build:

make tls

make frontend

make api

make cli

make mcp

# Build everything statically

static:

make tls-static

make api-static

make cli-static

make mcp-static

# Build TLS endpoint

tls:

go build $(BUILD_ARGS) -o $(OUTPUT)/$(TLS_NAME) $(TLS_CODE)

# Build TLS endpoint statically

tls-static:

go build $(BUILD_ARGS) $(STATIC_ARGS) -o $(OUTPUT)/$(TLS_NAME) -a $(TLS_CODE)

# Build API

api:

go build $(BUILD_ARGS) -o $(OUTPUT)/$(API_NAME) $(API_CODE)

# Build API statically

api-static:

go build $(BUILD_ARGS) $(STATIC_ARGS) -o $(OUTPUT)/$(API_NAME) -a $(API_CODE)

# Generate Swagger 2.0 YAML and JSON files from API annotations

swagger:

$(SWAG) init -d $(API_DIR),$(API_DIR)/handlers,pkg/types,pkg/nodes,pkg/queries,pkg/environments,pkg/users,pkg/settings,pkg/tags,pkg/carves -g main.go -o $(SWAG_OUTPUT_DIR) --outputTypes yaml,json --parseDependencyLevel 1

# Generate Swagger 2.0 docs and update the OpenAPI 3 spec

openapi:

./tools/update-openapi.sh

# Verify generated API docs are up to date

openapi-check:

./tools/update-openapi.sh --check

# Build the CLI

cli:

go build $(BUILD_ARGS) -o $(OUTPUT)/$(CLI_NAME) $(CLI_CODE)

# Build the CLI statically

cli-static:

go build $(BUILD_ARGS) $(STATIC_ARGS) -o $(OUTPUT)/$(CLI_NAME) -a $(CLI_CODE)

# Build the MCP server

mcp:

go build $(BUILD_ARGS) -o $(OUTPUT)/$(MCP_NAME) $(MCP_CODE)

# Build the MCP server statically

mcp-static:

go build $(BUILD_ARGS) $(STATIC_ARGS) -o $(OUTPUT)/$(MCP_NAME) -a $(MCP_CODE)

# ---------------------------------------------------------------------------

# React admin frontend (Vite + TypeScript SPA, served by nginx)

# ---------------------------------------------------------------------------

# Install JS deps (use ci when a lockfile is present, install otherwise).

frontend-install:

cd $(FRONTEND_DIR) && \

if [ -f package-lock.json ]; then npm ci --no-audit --no-fund; \

else npm install --no-audit --no-fund; fi

# Local dev server (Vite on :5173, proxies /api → :8081).

frontend-dev:

cd $(FRONTEND_DIR) && npm run dev

# Run vitest + tsc.

frontend-test:

cd $(FRONTEND_DIR) && npm test && npm run check

# Build the production bundle into frontend/dist/.

frontend-build:

cd $(FRONTEND_DIR) && npm run build

# Update the frontend dependencies (package.json + package-lock.json).

frontend-update:

cd $(FRONTEND_DIR) && npm update --no-audit --no-fund

# One-shot: install + build (used by CI / Docker builds).

frontend: frontend-install frontend-build

# Clean the dist directory

clean-dist:

rm -rf $(DIST)

# Delete all compiled binaries

clean:

rm -rf $(OUTPUT)/$(TLS_NAME)

rm -rf $(OUTPUT)/$(API_NAME)

rm -rf $(OUTPUT)/$(CLI_NAME)

make clean-dist

# Dekete all dependencies go.sum files

clean_go:

find . -name "go.sum" -type f -exec rm -rf {} \;

# Remove all unused dependencies

tidy:

make clean

make clean_go

go mod tidy

# Keep dependencies up to date

deps-update:

ifeq (,$(wildcard go.mod))

$(error Missing go.mod file)

endif

go get -u ./...

# Install everything

# optional DEST=destination_path

install:

make clean

make build

make install_tls

make install_api

make install_cli

# Install TLS server and restart service

# optional DEST=destination_path

install_tls:

sudo systemctl stop $(TLS_NAME)

sudo cp $(OUTPUT)/$(TLS_NAME) $(DEST)/$(OUTPUT)/$(TLS_NAME)

sudo systemctl start $(TLS_NAME)

# Install API server and restart service

# optional DEST=destination_path

install_api:

sudo systemctl stop $(API_NAME)

sudo cp $(OUTPUT)/$(API_NAME) $(DEST)/$(OUTPUT)/$(API_NAME)

sudo systemctl start $(API_NAME)

# Install CLI

# optional DEST=destination_path

install_cli:

sudo cp $(OUTPUT)/$(CLI_NAME) $(DEST)/$(OUTPUT)/$(CLI_NAME)

# Install frontend

# optional DEST=destination_path

install_frontend:

sudo rsync -av $(FRONTEND_DIR)/$(DIST)/ $(DEST)/$(FRONTEND_DIR)/

sudo chown -R www-data:www-data $(DEST)/$(FRONTEND_DIR)

# Display systemd logs for TLS server

logs_tls:

sudo journalctl -f -t $(TLS_NAME)

# Display docker logs for TLS server

docker_dev_logs_tls:

docker logs -f $(TLS_NAME)-dev

# Display systemd logs for frontend server

logs_frontend:

sudo journalctl -f -t $(FRONTEND_NAME)

# Display docker logs for frontend server

docker_dev_logs_frontend:

docker logs -f $(FRONTEND_NAME)-dev

# Display systemd logs for API server

logs_api:

sudo journalctl -f -t $(API_NAME)

# Display docker logs for API server

docker_dev_logs_api:

docker logs -f $(API_NAME)-dev

# Display docker logs for nginx server

docker_dev_logs_nginx:

docker logs -f osctrl-nginx-dev

# Display docker logs for osquery clients

docker_dev_logs_osquery-1:

docker logs -f osctrl-osquery-1-dev

docker_dev_logs_osquery-2:

docker logs -f osctrl-osquery-2-dev

docker_dev_logs_osquery-3:

docker logs -f osctrl-osquery-3-dev

# Display docker logs for postgresql server

docker_dev_logs_postgresql:

docker logs -f osctrl-postgres-dev

# Display docker logs for redis server

docker_dev_logs_redis:

docker logs -f osctrl-redis-dev

# Docker shell into TLS server

docker_dev_shell_tls:

docker exec -it $(TLS_NAME)-dev /bin/bash

# Docker shell into frontend server

docker_dev_shell_frontend:

docker exec -it $(FRONTEND_NAME)-dev /bin/bash

# Docker shell into API server

docker_dev_shell_api:

docker exec -it $(API_NAME)-dev /bin/bash

# Docker shell into osquery client

docker_dev_shell_osquery:

docker exec -it osctrl-osquery-dev /bin/bash

# Docker shell into postgresql server

docker_dev_shell_postgres:

docker exec -it osctrl-postgres-dev /bin/bash

# Docker shell into redis server

docker_dev_shell_redis:

docker exec -it osctrl-redis-dev /bin/sh

# Generate self-signed TLS certificates for docker dev environment

docker_dev_certs:

openssl req -x509 -newkey rsa:4096 -sha256 -days 365 -nodes \

-keyout deploy/docker/conf/tls/osctrl.key \

-out deploy/docker/conf/tls/osctrl.crt \

-config deploy/docker/conf/tls/openssl.cnf

# Build dev docker containers and run them (also generates new certificates)

docker_dev_build:

ifeq (,$(wildcard ./.env))

$(error Missing .env file. Run: cp .env.example .env)

endif

ifeq (,$(wildcard ./deploy/docker/conf/tls/osctrl.crt))

$(error Missing TLS certificate file. Run: make docker_dev_certs)

endif

ifeq (,$(wildcard ./deploy/docker/conf/tls/osctrl.key))

$(error Missing TLS private key file. Run: make docker_dev_certs)

endif

docker compose -f docker-compose-dev.yml build --provenance=false

# Build and run dev docker containers

make docker_dev:

make docker_dev_build

make docker_dev_up

# Run docker containers

docker_dev_up:

docker compose -f docker-compose-dev.yml up

up-backend:

docker compose -f docker-compose-dev.yml up osctrl-postgres osctrl-redis

# Takes down docker containers

docker_dev_down:

docker compose -f docker-compose-dev.yml down

# Deletes all osctrl docker images and volumes

docker_dev_clean:

docker images --format table | grep osctrl | awk '{print $$3}' | xargs -rI {} docker rmi -f {}

docker volume ls | grep osctrl | awk '{print $$2}' | xargs -rI {} docker volume rm {}

# Rebuild only the TLS server

docker_dev_rebuild_tls:

docker compose -f docker-compose-dev.yml up --force-recreate --no-deps -d --build $(TLS_NAME)

# Rebuild only the frontend server

docker_dev_rebuild_frontend:

docker compose -f docker-compose-dev.yml up --force-recreate --no-deps -d --build $(FRONTEND_NAME)

# Rebuild only the CLI

docker_dev_rebuild_cli:

docker compose -f docker-compose-dev.yml up --force-recreate --no-deps -d --build $(CLI_NAME)

# Rebuild only the API server

docker_dev_rebuild_api:

docker compose -f docker-compose-dev.yml up --force-recreate --no-deps -d --build $(API_NAME)

# Deploy osctrl in a single server using the provision.sh script

provision_dev:

./deploy/provision.sh -m "$(DEV_ENV)" -s /home/$(DEV_USER)/osctrl -t self -p all --nginx --postgres -E -R --tls-hostname "$(DEV_IP)" --admin-hostname "$(DEV_IP)" --api-hostname "$(DEV_IP)" -X admin

# Run linter

lint:

golangci-lint run

# Run all tests

test:

go clean -testcache ./...

go test ./utils -v

go test ./cmd/tls/handlers -v

# Check test coverage

test_cover:

cd utils && go test -cover .

cd cmd/tls/handlers && go test -cover .

# Build snapshot binaries with GoReleaser

release-build:

make clean-dist

./tools/gorelease.sh build

# Check GoReleaser configuration

release-check:

./tools/gorelease.sh check

# Initialize GoReleaser configuration

release-init:

./tools/gorelease.sh init

# Create a release (requires tag)

release:

make clean-dist

./tools/gorelease.sh release

# Build and test release locally

release-test:

make release-build

@echo "Testing built binaries..."

@for binary in $(DIST)/osctrl-*; do \

if [ -f "$$binary" ] && [ -x "$$binary" ]; then \

echo "Testing $$binary"; \

$$binary --version || $$binary version || echo "No version flag available"; \

fi; \

done

# Merge locally develop into main, usually to prepare for release

develop-merge:

git pull

git checkout main

git pull origin main

git merge develop

git push origin main

osctrl/Makefile at develop · jmpsec/osctrl · GitHub

Uh oh!

Expand file tree

Breadcrumbs

Makefile

Latest commit

History

Breadcrumbs

Makefile

File metadata and controls