// OpenRCInitSystem defines openrc
type OpenRCInitSystem struct{}

// ServiceStart tries to start a specific service
func (openrc OpenRCInitSystem) ServiceStart(service string) error {
	args := []string{service, "start"}
	return exec.Command("rc-service", args...).Run()
}

// ServiceStop tries to stop a specific service
func (openrc OpenRCInitSystem) ServiceStop(service string) error {
	args := []string{service, "stop"}

type InitSystem interface {
	// EnableCommand returns a string describing how to enable a service
	EnableCommand(service string) string

	// ServiceStart tries to start a specific service
	ServiceStart(service string) error

	// ServiceStop tries to stop a specific service
	ServiceStop(service string) error

	// ServiceRestart tries to reload the environment and restart the specific service
	ServiceRestart(service string) error

func (sysd WindowsInitSystem) ServiceRestart(service string) error {
	if err := sysd.ServiceStop(service); err != nil {
		return errors.Wrapf(err, "couldn't stop service %s", service)
	}
	if err := sysd.ServiceStart(service); err != nil {
		return errors.Wrapf(err, "couldn't start service %s", service)
	}

	return nil
}

// ServiceStop tries to stop a specific service

Class <org.gradle.api.Project> is not annotated with @ServiceScope in (Project.java:0)
Class <org.gradle.api.artifacts.dsl.DependencyFactory> is not annotated with @ServiceScope in (DependencyFactory.java:0)
Class <org.gradle.api.artifacts.dsl.DependencyHandler> is not annotated with @ServiceScope in (DependencyHandler.java:0)
Class <org.gradle.api.artifacts.dsl.DependencyLockingHandler> is not annotated with @ServiceScope in (DependencyLockingHandler.java:0)

 * <p>
 * Only services that are annotated with {@link ServiceScope} are validated.
 */
@NonNullApi
class ServiceScopeValidator implements AnnotatedServiceLifecycleHandler {

    private static final List<Class<? extends Annotation>> SCOPE_ANNOTATIONS = Collections.<Class<? extends Annotation>>singletonList(ServiceScope.class);

    private final Class<? extends Scope> scope;
    private final boolean strict;

        return new ScopedServiceRegistry(scope, strict, "test service registry")
    }

    @ServiceScope(Scope.BuildTree)
    static class BuildTreeScopedService {}

    @ServiceScope([Scope.Global, Scope.Build])
    static class GlobalAndBuildScopedService {}

    static class UnscopedService {}

     * validate all registered services for being annotated with the given scope.
     * <p>
     * However, this still allows to register services without the
     * {@link org.gradle.internal.service.scopes.ServiceScope @ServiceScope} annotation.
     *
     * @see #scopeStrictly(Class)
     */
    public ServiceRegistryBuilder scope(Class<? extends Scope> scope) {
        this.scope = scope;
        this.strict = false;

 * limitations under the License.
 */

package org.gradle.internal.scripts;

import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

@ServiceScope(Scope.Global.class)
public interface ScriptFileResolverListeners {

    void addListener(ScriptFileResolvedListener scriptFileResolvedListener);

 */

package org.gradle.internal.environment;

import org.gradle.internal.scan.UsedByScanPlugin;
import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

@UsedByScanPlugin
@ServiceScope(Scope.Global.class)
public interface GradleBuildEnvironment {

    boolean isLongLivingProcess();

 */

package org.gradle.internal.build.event;

import org.gradle.initialization.BuildEventConsumer;
import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

@ServiceScope(Scope.Global.class)
public interface BuildEventListenerFactory {
    Iterable<Object> createListeners(BuildEventSubscriptions subscriptions, BuildEventConsumer consumer);