def put_mirror_channel_actions(
action: rest_models.ChannelAction,
channel: db_models.Channel = Depends(get_channel_allow_proxy),
dao: Dao = Depends(get_dao),
task: Task = Depends(get_tasks_worker),
):
task.execute_channel_action(action.action, channel)
def get_tasks_worker(
background_tasks: BackgroundTasks,
dao: Dao = Depends(get_dao),
auth: authorization.Rules = Depends(get_rules),
session: requests.Session = Depends(get_remote_session),
config: Config = Depends(get_config),
) -> Task:
if config.configured_section("worker"):
worker = config.worker_type
else:
worker = "thread"
if worker == "thread":
worker = ThreadingWorker(background_tasks, dao, auth, session, config)
elif worker == "subprocess":
worker = SubprocessWorker(auth.API_key, auth.session, config)
elif worker == "redis":
if rq_available:
worker = RQManager(
config.worker_redis_ip,
config.worker_redis_port,
config.worker_redis_db,
auth.API_key,
auth.session,
config,
)
else:
raise ValueError("redis and rq not installed on machine")
else:
raise ValueError("wrong configuration in worker.type")
return Task(auth, worker)
def get_tasks_worker(
background_tasks: BackgroundTasks,
dao: Dao = Depends(get_dao),
auth: authorization.Rules = Depends(get_rules),
session: requests.Session = Depends(get_remote_session),
config: Config = Depends(get_config),
) -> Task:
return Task(auth, dao.db)
def post_channel(
new_channel: rest_models.Channel,
background_tasks: BackgroundTasks,
dao: Dao = Depends(get_dao),
auth: authorization.Rules = Depends(get_rules),
task: Task = Depends(get_tasks_worker),
remote_session: requests.Session = Depends(get_remote_session),
):
user_id = auth.assert_user()
channel = dao.get_channel(new_channel.name)
if channel:
raise HTTPException(
status_code=status.HTTP_409_CONFLICT,
detail=f"Channel {new_channel.name} exists",
)
if not new_channel.mirror_channel_url:
auth.assert_create_channel()
is_mirror = new_channel.mirror_channel_url and new_channel.mirror_mode == "mirror"
is_proxy = new_channel.mirror_channel_url and new_channel.mirror_mode == "proxy"
if is_mirror:
auth.assert_create_mirror_channel()
if is_proxy:
auth.assert_create_proxy_channel()
if new_channel.metadata.actions is None:
if is_mirror:
actions = [ChannelActionEnum.synchronize]
else:
actions = []
else:
actions = new_channel.metadata.actions
channel = dao.create_channel(new_channel, user_id, authorization.OWNER)
for action in actions:
task.execute_channel_action(action, channel)
def put_mirror_channel_actions(
action: rest_models.ChannelAction,
channel: db_models.Channel = Depends(get_channel_allow_proxy),
dao: Dao = Depends(get_dao),
task: Task = Depends(get_tasks_worker),
):
new_job = task.execute_channel_action(
action.action,
channel,
start_at=action.start_at,
repeat_every_seconds=action.repeat_every_seconds,
)
return new_job
def get_tasks_worker(
background_tasks: BackgroundTasks,
dao: Dao = Depends(get_dao),
auth: authorization.Rules = Depends(get_rules),
session: requests.Session = Depends(get_remote_session),
config: Config = Depends(get_config),
) -> Task:
if config.configured_section("worker"):
worker = config.worker_type
else:
worker = "thread"
if worker == "thread":
worker = ThreadingWorker(background_tasks, dao, auth, session, config)
else:
raise ValueError("wrong configuration in worker.type")
return Task(auth, worker)
def post_channel(
request: Request,
new_channel: rest_models.Channel,
background_tasks: BackgroundTasks,
mirror_api_key: Optional[str] = None,
register_mirror: bool = False,
dao: Dao = Depends(get_dao),
auth: authorization.Rules = Depends(get_rules),
task: Task = Depends(get_tasks_worker),
config=Depends(get_config),
session: requests.Session = Depends(get_remote_session),
):
user_id = auth.assert_user()
existing_channel = dao.get_channel(new_channel.name)
if existing_channel:
raise HTTPException(
status_code=status.HTTP_409_CONFLICT,
detail=f"Channel {new_channel.name} exists",
)
if not new_channel.mirror_channel_url:
auth.assert_create_channel()
is_mirror = new_channel.mirror_channel_url and new_channel.mirror_mode == "mirror"
is_proxy = new_channel.mirror_channel_url and new_channel.mirror_mode == "proxy"
if is_mirror:
auth.assert_create_mirror_channel()
if is_proxy:
auth.assert_create_proxy_channel()
if new_channel.actions is None:
if is_mirror:
actions = [ChannelActionEnum.synchronize_repodata]
else:
actions = []
else:
actions = new_channel.actions
includelist = new_channel.metadata.includelist
excludelist = new_channel.metadata.excludelist
if includelist is not None and excludelist is not None:
raise HTTPException(
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
detail="Cannot use both `includelist` and `excludelist` together.",
)
user_attrs = new_channel.dict(exclude_unset=True)
if "size_limit" in user_attrs:
auth.assert_set_channel_size_limit()
size_limit = new_channel.size_limit
else:
if config.configured_section("quotas"):
size_limit = config.quotas_channel_quota
else:
size_limit = None
channel = dao.create_channel(new_channel, user_id, authorization.OWNER,
size_limit)
pkgstore.create_channel(new_channel.name)
indexing.update_indexes(dao, pkgstore, new_channel.name)
# register mirror
if is_mirror and register_mirror:
mirror_url = str(new_channel.mirror_channel_url)
mirror_url = mirror_url.replace("get", "api/channels")
headers = {"x-api-key": mirror_api_key} if mirror_api_key else {}
api_endpoint = str(
request.url.replace(query=None)) + '/' + new_channel.name
request.url
response = session.post(
mirror_url + '/mirrors',
json={
"url": api_endpoint.replace("api/channels", "get"),
"api_endpoint": api_endpoint,
"metrics_endpoint": api_endpoint.replace("api", "metrics"),
},
headers=headers,
)
if response.status_code != 201:
logger.warning(
f"could not register mirror due to error {response.text}")
for action in actions:
task.execute_channel_action(
action,
channel,
)