* limitations under the License.
 */

package org.gradle.caching.internal.tasks;

import java.io.IOException;
import java.io.InputStream;

public interface DataSource extends DataItem {
    InputStream openInput() throws IOException;
    long getLength() throws IOException;

local g = import './g.libsonnet';
local var = g.dashboard.variable;

{
  datasource:
    var.datasource.new('datasource', 'prometheus'),

  cluster:
    var.query.new('cluster')
    + var.query.withDatasourceFromVariable(self.datasource)
    + var.query.queryTypes.withLabelValues(
      'cluster',
      'process_cpu_seconds_total',
    )
    + var.query.withRefresh('time')
    + var.query.selectionOptions.withMulti()

            config.setMaxLifetime(MAX_LIFETIME_MS);
            dataSource = new HikariDataSource(config);

            executeInitializers(dataSource);
        }
        return dataSource.getConnection();
    }

    private void executeInitializers(DataSource dataSource) throws SQLException {
        try (Connection connection = dataSource.getConnection()) {

		return false
	}
	if oldPVCSpec.DataSource != nil || oldPVCSpec.DataSourceRef != nil {
		return true
	}
	return false
}

func dataSourceIsPvcOrSnapshot(dataSource *core.TypedLocalObjectReference) bool {
	if dataSource != nil {
		apiGroup := ""
		if dataSource.APIGroup != nil {
			apiGroup = *dataSource.APIGroup
		}
		if dataSource.Kind == pvc &&
			apiGroup == "" {
			return true
		}

			pvc := new(api.PersistentVolumeClaim)
			if test.dataSource {
				pvc.Spec.DataSource = dataSource.DeepCopy()
			}
			if test.dataSourceRef {
				pvc.Spec.DataSourceRef = dataSourceRef.DeepCopy()
			}
			var expectDataSource *api.TypedLocalObjectReference
			if test.want {
				expectDataSource = &dataSource
			}
			var expectDataSourceRef *api.TypedObjectReference
			if test.wantRef {

        this.buffer = new byte[bufferSizeInKBytes * 1024];
    }

    @Override
    public void pack(List<DataSource> inputs, DataTarget output) throws IOException {
        TarOutputStream tarOutput = new TarOutputStream(output.openOutput());
        for (DataSource input : inputs) {
            @SuppressWarnings("OctalInteger")

            random.nextBytes(buffer);
            DataSource input = accessor.createSource(name, buffer, Level.Trial);
            inputs.add(input);
        }
        return inputs.build();
    }

    private static DataSource packSample(String name, List<DataSource> inputs, Packer packer, DataAccessor accessor) throws IOException {
        long sumLength = 0;
        for (DataSource input : inputs) {

        this.buffer = new byte[bufferSizeInKBytes];
    }

    @Override
    public void pack(List<DataSource> inputs, DataTarget output) throws IOException {
        ZipOutputStream zipOutput = new ZipOutputStream(output.openOutput());
        for (DataSource input : inputs) {
            ZipEntry entry = new ZipEntry(input.getName());
            entry.setSize(input.getLength());

 */

package org.gradle.caching.internal.tasks;

import java.io.IOException;
import java.io.InputStream;

public abstract class DelegatingDataSource implements DataSource {
    private final DataSource delegate;

    public DelegatingDataSource(DataSource delegate) {
        this.delegate = delegate;
    }

    @Override
    public InputStream openInput() throws IOException {
        return delegate.openInput();
    }

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class InMemoryDataAccessor implements DataAccessor {
    @Override
    public DataSource createSource(String name, byte[] bytes, Level level) {
        return new Source(name, bytes);
    }

    @Override
    public DataTarget createTarget(String name, Level level) {
        return new Target(name);