def _create_node_container(cls) -> DockerContainer:
container = DockerContainer(
cls.IMAGE,
)
if cls.PORT:
container.ports[8732] = cls.PORT
return container
def test_docker_generic_db():
mongo_container = DockerContainer(image_name="mongo",
version="latest",
container_name="mongodb")
mongo_container.bind_ports(27017, 27017)
with mongo_container:
@wait_container_is_ready()
def connect():
return MongoClient("mongodb://0.0.0.0:27017")
db = connect().primer
result = db.restaurants.insert_one({
"address": {
"street": "2 Avenue",
"zipcode": "10075",
"building": "1480",
"coord": [-73.9557413, 40.7720266]
},
"borough": "Manhattan",
"cuisine": "Italian",
"name": "Vella",
"restaurant_id": "41704620"
})
print(result.inserted_id)
cursor = db.restaurants.find({"borough": "Manhattan"})
for document in cursor:
print(document)
def _setup_minio(self):
self.minio = DockerContainer(self.minio_image)
self.minio.with_exposed_ports(9000).with_exposed_ports(9001).with_env(
"MINIO_ROOT_USER", self.access_key
).with_env("MINIO_ROOT_PASSWORD", self.secret).with_command(
'server /data --console-address ":9001"'
)
self.minio.start()
log_string_to_wait_for = (
"API" # The minio container will print "API: ..." when ready.
)
wait_for_logs(container=self.minio, predicate=log_string_to_wait_for, timeout=5)
def _create_node_container(cls) -> DockerContainer:
return DockerContainer(cls.IMAGE, )
class S3FileDataSourceCreator(DataSourceCreator):
f: Any
minio: DockerContainer
bucket = "feast-test"
access_key = "AKIAIOSFODNN7EXAMPLE"
secret = "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
minio_image = "minio/minio:RELEASE.2021-08-17T20-53-08Z"
def __init__(self, _: str):
self._setup_minio()
def _setup_minio(self):
self.minio = DockerContainer(self.minio_image)
self.minio.with_exposed_ports(9000).with_exposed_ports(9001).with_env(
"MINIO_ROOT_USER", self.access_key).with_env(
"MINIO_ROOT_PASSWORD", self.secret).with_command(
'server /data --console-address ":9001"')
self.minio.start()
log_string_to_wait_for = (
"API" # The minio container will print "API: ..." when ready.
)
wait_for_logs(container=self.minio,
predicate=log_string_to_wait_for,
timeout=5)
def _upload_parquet_file(self, df, file_name, minio_endpoint):
self.f = tempfile.NamedTemporaryFile(suffix=".parquet", delete=False)
df.to_parquet(self.f.name)
client = Minio(
minio_endpoint,
access_key=self.access_key,
secret_key=self.secret,
secure=False,
)
if not client.bucket_exists(self.bucket):
client.make_bucket(self.bucket)
client.fput_object(
self.bucket,
file_name,
self.f.name,
)
def create_data_source(
self,
df: pd.DataFrame,
destination_name: Optional[str] = None,
suffix: Optional[str] = None,
timestamp_field="ts",
created_timestamp_column="created_ts",
field_mapping: Dict[str, str] = None,
) -> DataSource:
filename = f"{destination_name}.parquet"
port = self.minio.get_exposed_port("9000")
host = self.minio.get_container_host_ip()
minio_endpoint = f"{host}:{port}"
self._upload_parquet_file(df, filename, minio_endpoint)
return FileSource(
file_format=ParquetFormat(),
path=f"s3://{self.bucket}/{filename}",
timestamp_field=timestamp_field,
created_timestamp_column=created_timestamp_column,
field_mapping=field_mapping or {"ts_1": "ts"},
s3_endpoint_override=f"http://{host}:{port}",
)
def create_saved_dataset_destination(self) -> SavedDatasetFileStorage:
port = self.minio.get_exposed_port("9000")
host = self.minio.get_container_host_ip()
return SavedDatasetFileStorage(
path=f"s3://{self.bucket}/persisted/{str(uuid.uuid4())}",
file_format=ParquetFormat(),
s3_endpoint_override=f"http://{host}:{port}",
)
def get_prefixed_table_name(self, suffix: str) -> str:
return f"{suffix}"
def create_offline_store_config(self) -> FeastConfigBaseModel:
return FileOfflineStoreConfig()
def teardown(self):
self.minio.stop()
self.f.close()
def test_container_port():
cont = DockerContainer("selenium/hub", "latest", "selenium_hub")
cont.start()
assert cont.get_host_info(4444) > 0