"k8s.io/client-go/util/homedir"

	"istio.io/istio/pkg/lazy"
)

var _ PartialFactory = &clientFactory{}

// clientFactory partially implements the kubectl util.Factory, which is provides access to various k8s clients.
// The full Factory can be built with MakeKubeFactory.
// This split is to avoid huge dependencies.
type clientFactory struct {
	clientConfig clientcmd.ClientConfig

	expander lazy.Lazy[meta.RESTMapper]

                .singleton("clientFactory", CrawlerClientFactory.class);
        clientFactory = container.getComponent("clientFactory");
        FaultTolerantClient httpClient = container.getComponent("httpClient");
        httpClient.setCrawlerClient(new HcHttpClient());
        clientFactory.addClient("http:.*", httpClient);
        clientFactory.addClient("https:.*", httpClient);

    @Resource
    protected CrawlerContainer crawlerContainer;

    @Resource
    protected IntervalController intervalController;

    @Resource
    protected CrawlerClientFactory clientFactory;

    protected CrawlerContext crawlerContext;

    protected boolean background = false;

    protected boolean daemon = false;

    protected int threadPriority = Thread.NORM_PRIORITY;

    private final SftpClientFactory clientFactory;
    private final ExternalResourceMetaData metaData;
    private final URI uri;
    private final PasswordCredentials credentials;

    private LockableSftpClient client;

    public SftpResource(SftpClientFactory clientFactory, ExternalResourceMetaData metaData, URI uri, PasswordCredentials credentials) {
        this.clientFactory = clientFactory;
        this.metaData = metaData;

            return new SftpClientFactory();
        }

        @Provides
        ResourceConnectorFactory createSftpConnectorFactory(SftpClientFactory clientFactory) {
            return new SftpConnectorFactory(clientFactory);
        }
    }

    }

    public void setNoWaitOnFolder(final boolean noWaitOnFolder) {
        this.noWaitOnFolder = noWaitOnFolder;
    }

    public void setClientFactory(final CrawlerClientFactory clientFactory) {
        this.clientFactory = clientFactory;
    }

    public void setCrawlerContext(final CrawlerContext crawlerContext) {
        this.crawlerContext = crawlerContext;
    }

func newClientInternal(clientFactory *clientFactory, opts ...ClientOption) (*client, error) {
	var c client
	var err error

	c.clientFactory = clientFactory

	c.config, err = clientFactory.ToRESTConfig()
	if err != nil {
		return nil, err
	}

	for _, opt := range opts {
		opt(&c)
	}

	c.restClient, err = clientFactory.RESTClient()
	if err != nil {
		return nil, err

		<property name="charset">"UTF-8"</property>
	</component>

	<component name="crawlerClientCreator"
		class="org.codelibs.fess.crawler.client.CrawlerClientCreator">
	</component>

	<component name="clientFactory"
		class="org.codelibs.fess.crawler.client.CrawlerClientFactory" instance="prototype">
		<postConstruct name="addClient">
			<arg>["http:.*", "https:.*"]</arg>
			<arg>httpClient</arg>
		</postConstruct>

                return e.getFirst();
            }
            return null;
        }).filter(StringUtil::isNotBlank).findFirst()//
                .map(s -> clientFactory.getClient(s + ":" + url))//
                .orElseGet(() -> clientFactory.getClient(url));
        if (logger.isDebugEnabled()) {
            logger.debug("CrawlerClient: {}", client.getClass().getCanonicalName());
        }
        return client;

                }).singleton("dataHelper", MemoryDataHelper.class).singleton("robotsTxtHelper", RobotsTxtHelper.class)
                .<CrawlerClientFactory> singleton("clientFactory", CrawlerClientFactory.class, factory -> {
                    factory.addClient("http:.*", container.getComponent("httpClient"));
                    factory.addClient("file:.*", container.getComponent("fsClient"));