AbleOS/repo_server
3
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

Compare commits

...

4 commits
phoenix ... trunk

Author SHA1 Message Date
Able 3ebbab562d Working on a better router system. 2025-03-16 19:49:51 -05:00
Able 914e6a10b9 breakage 2025-03-16 19:37:28 -05:00
Able c717faa947 REPO: cleanup work 2025-02-22 07:21:10 -06:00
Able 65d28b28d4 MISC: Varios changes 2025-02-21 09:22:09 -06:00
11 changed files with 186 additions and 29 deletions

11
assets/html/repo.html Normal file
View file

@ -0,0 +1,11 @@
<!DOCTYPE html>
<html>
<head>
<title>Repo- ~(repo_name)</title>
</head>
<body>
<h1>~(repo_name)</h1>
</body>
</html>

2
assets/repos.txt Normal file
View file

@ -0,0 +1,2 @@
core
core/kernels

48
lib/client_handler.ex
View file

@ -23,38 +23,44 @@ defmodule RlRepo.ClientHandler do
def create_response(request) do
# TODO: Split off the info I need from the request body and I guess pass it around also
Logger.info("REQUEST BODY #{request}")
Logger.info("REQUEST BODY\n#{request}")
Logger.info("Building response body.")
[get_line | rest] = String.split(request, "\n\r")
a = String.split(request, "\n\r")
[get_line | _rest] = a
Logger.info("get-line #{get_line}")
b = String.split(get_line, " ")
[request_type | rest] = b
[path | rest] = rest
Logger.info("#{request_type} #{path}")
Logger.info("REQ_TYPE #{request_type}")
[path | _rest] = rest
Logger.info("PATH #{path}")
# Parse path ignoring leading and trailing slash
split_path = String.split(path, "/", trim: true)
# Parse path
# split_path = String.split(path, "/", trim: true)
# split_path_length = length(split_path)
split_path_length = length(split_path)
# # TODO: Handle routing here.
# case split_path_length do
# 1 ->
# RlRepo.Router.parse_1_segment_path(split_path)
# |> RlRepo.Router.route_1(request_type)
case split_path_length do
1 ->
RlRepo.Router.parse_1_segment_path(rest)
|> RlRepo.Router.route_1(request_type)
# 3 ->
# RlRepo.Router.parse_3_segment_path(split_path)
# |> RlRepo.Router.route_3(request_type)
3 ->
RlRepo.Router.parse_3_segment_path(rest)
|> RlRepo.Router.route_3(request_type)
# 4 ->
# RlRepo.Router.parse_4_segment_path(split_path)
# |> RlRepo.Router.route_4(request_type)
4 ->
RlRepo.Router.parse_4_segment_path(rest)
|> RlRepo.Router.route_4(request_type)
# # Note: Error handling.
# _ ->
# RlRepo.Router.status_404()
# end
Router.Api.lookup_route(path)
# Note: Error handling.
_ ->
RlRepo.Router.status_404()
end
end
def create_return_code_string(return_code) do

11
lib/json.ex
View file

@ -3,7 +3,14 @@ defmodule RlRepo.Json do
@moduledoc """
"""
def fmt_json(a) do
"{\"pkg_names\": 10}"
def map_to_json(a) do
# msg = ""
"{" <>
kv_step("", "key", "value") <>
"}"
end
def kv_step(msg, key, value) do
msg <> "\"#{key}\" : \"#{value}\""
end
end

58
lib/repo/repo_lookup.ex Normal file
View file

@ -0,0 +1,58 @@
defmodule RepoLookup do
require Logger
def is_repo?(string) do
send(:repo_lookup, {"is_repo?", string, self()})
receive do
{"is_repo", value} ->
value
end
end
def repo_contains_pkg?(repo_name, pkg) do
send(:repo_lookup, {"repo_contains_pkg?", repo_name, pkg, self()})
receive do
{"repo_contains_pkg?", value} ->
value
end
end
def alias_check() do
# Set this process up to allow finding it via the :repo_lookup alias
if Enum.member?(Process.registered(), :repo_lookup) do
# Process.unalias(:repo_lookup)
end
Process.register(self(), :repo_lookup)
end
def start_repo_lookup() do
Logger.info("Repo spinning.")
alias_check()
Logger.info("Logger process alias registered")
loop_repo_lookup()
end
def loop_repo_lookup() do
Logger.info("Repo Lookup loop")
receive do
{"is_repo", value, return_pid} ->
Logger.info("Checking #{value}")
send(return_pid, {"is_repo", false})
{"repo_contains_pkg?", repo_name, pkg_name, pid}
->
Logger.info "Checking repo #{repo_name} for pkg #{pkg_name}"
send(pid, {"repo_contains_pkg?", false})
end
loop_repo_lookup()
end
end

12
lib/rl_repo.ex
View file

@ -13,6 +13,18 @@ defmodule RlRepo do
Logger.info("Listening on port #{port}")
# Spawn the router.
Task.Supervisor.start_child(Router, fn ->
Router.start()
end)
# Spawn RepoLookup
Task.Supervisor.start_child(RlRepo.QueryServices, fn ->
RepoLookup.start_repo_lookup()
end)
loop_acceptor(listener_socket)
end

3
lib/rl_repo/application.ex
View file

@ -10,6 +10,9 @@ defmodule RlRepo.Application do
port = String.to_integer(System.get_env("PORT") || "10002")
children = [
{Task.Supervisor, name: RlRepo.QueryServices},
{Task.Supervisor, name: Router},
# Starts a worker by calling: RlRepo.Worker.start_link(arg)
# {RlRepo.Worker, arg}
Supervisor.child_spec({Task, fn -> RlRepo.start(port) end}, restart: :permanent)

29
lib/router/router.ex Normal file
View file

@ -0,0 +1,29 @@
defmodule Router do
require Logger
def start() do
info = %{
routes: %{
"" => "repo"
}
}
Process.register(self(), :router)
loop_router(info)
end
defp loop_router(info) do
receive do
{:route, value, return_pid} ->
Logger.info "Route recieved #{value}"
send(return_pid, {:route, :exists, "template example."})
# code
{:route, :register, route, template} ->
Logger.info "Route registration attempt."
end
loop_router(info)
end
end

20
lib/router/router_api.ex Normal file
View file

@ -0,0 +1,20 @@
defmodule Router.Api do
require Logger
# Search for a route.
def lookup_route(route) do
send(:router, {:route, route, self()})
receive do
{:route, :exists, template} ->
Logger.info "Found route."
# {200, template}
placeholders = %{"repo_name" => "test"}
{200, "text/html", RlRepo.Template.template("repo", placeholders)}
# code
end
end
end

19
lib/routing.ex
View file

@ -28,17 +28,26 @@ defmodule RlRepo.Router do
Logger.info("#{request_type}")
{repo_name, pkg_name, action} = path
if action == "info" do
Logger.info("fetching json")
if RepoLookup.is_repo?(repo_name) do
Logger.info("#{repo_name} is a repo.")
else
Logger.info("#{repo_name} is not a repo.")
end
{200, "application/json", "{\"pkg_name\": \"#{pkg_name}\"}"}
if action == "info" do
Logger.info("fetching json")
{200, "application/json", "{\"pkg_name\": \"#{pkg_name}\"}"}
end
placeholders = %{}
# {200, "text/html", "<p>REPO_PAGE</p>"}
{200, "text/html", RlRepo.Template.template("repo", placeholders)}
end
def route_4(path, request_type) do
Logger.info("#{request_type}")
{repo_name, sub_repo_name, pkg_name, action} = path
{200, "text/html", "<p>Hi</p>"}
# {repo_name, sub_repo_name, pkg_name, action} = path
{200, "application/json", RlRepo.Json.map_to_json(%{})}
end
def parse_1_segment_path(path) do

2
lib/templating.ex
View file

@ -16,7 +16,7 @@ defmodule RlRepo.Template do
end
def template_step(replacements, body, steps_left) do
[before_placeholder | rest] = split_path = String.split(body, "~(", parts: 2)
[before_placeholder | rest] = String.split(body, "~(", parts: 2)
[remains | _] = rest
[placeholder_name | after_placeholder] = String.split(remains, ")", parts: 2)
[after_placeholder | _] = after_placeholder