public async Task <IActionResult> CreateServerAsync([FromBody] CreateServerRequest Server)
{
string UserEmail = HttpContext.User?.FindFirst("Email")?.Value;
if (String.IsNullOrWhiteSpace(Server.server_name))
{
return(BadRequest(new { Error = "server name is invalid" }));
}
else
{
var response = await _ServerService.CreateServerAsync(Server.server_name, UserEmail);
if (response.IsSuccess)
{
return(Ok(new CreatServerResponse {
ServerKey = response.ServerKey,
ServerName = response.ServerName
}));
}
else
{
return(StatusCode(500, new { Errors = response.Errors }));
}
}
}
internal virtual CreateServerResponse CreateServer(CreateServerRequest request)
{
var marshaller = CreateServerRequestMarshaller.Instance;
var unmarshaller = CreateServerResponseUnmarshaller.Instance;
return(Invoke <CreateServerRequest, CreateServerResponse>(request, marshaller, unmarshaller));
}
/// <summary>
/// Initiates the asynchronous execution of the CreateServer operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the CreateServer operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/opsworkscm-2016-11-01/CreateServer">REST API Reference for CreateServer Operation</seealso>
public virtual Task <CreateServerResponse> CreateServerAsync(CreateServerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = CreateServerRequestMarshaller.Instance;
var unmarshaller = CreateServerResponseUnmarshaller.Instance;
return(InvokeAsync <CreateServerRequest, CreateServerResponse>(request, marshaller,
unmarshaller, cancellationToken));
}
/// <summary>
/// Initiates the asynchronous execution of the CreateServer operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the CreateServer operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/transfer-2018-11-05/CreateServer">REST API Reference for CreateServer Operation</seealso>
public virtual Task <CreateServerResponse> CreateServerAsync(CreateServerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateServerRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateServerResponseUnmarshaller.Instance;
return(InvokeAsync <CreateServerResponse>(request, options, cancellationToken));
}
internal virtual CreateServerResponse CreateServer(CreateServerRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateServerRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateServerResponseUnmarshaller.Instance;
return(Invoke <CreateServerResponse>(request, options));
}
public async Task <bool> Handle(CreateServerRequest message, IOutputPort <CreateNewServerResponse> outputPort)//, IOutputPort<CreateNewServerResponse> outputPort
{
var response = await _serverRepository.Create(new Server(Guid.NewGuid(), message.CreatedAt, message.CreatedBy, message.DeletedAt, message.DeletedBy, message.EndDate,
message.IpAddress, message.IsDeleted, message.Name,
message.StartDate, message.Status, message.UpdatedAt, message.UpdatedBy));
//outputPort.Handle(response.Success ? new CreateNewServerResponse(response.Id, true) : new CreateNewServerResponse(response.Errors.Select(e => e.Description)));
return(response.Success);
}
public override Task <CreateServerResponse> CreateServer(CreateServerRequest request, ServerCallContext context)
{
bool success = RequestsDispatcher.CreateServerProcess(GetServerArguments(request));
if (!success)
{
throw new RpcException(new Status(StatusCode.Internal, "Couldn't create server process."));
}
return(Task.FromResult(new CreateServerResponse()));
}
public CreateServerArguments GetServerArguments(CreateServerRequest request)
{
return(new CreateServerArguments {
ServerId = request.ServerId,
Host = request.Host,
Port = request.Port,
MinDelay = request.MinDelay,
MaxDelay = request.MaxDelay,
Version = request.Version
});
}
public async Task <IActionResult> CreateServer(
CreateServerRequest request,
CancellationToken cancellationToken)
{
var server = await Mediator.Send(
new CreateServerCommand(request.ServerName),
cancellationToken);
var response = new CreateServerResponse(server);
return(CreatedAtAction(
nameof(GetServer),
new { serverId = server.Id },
response));
}
//Servers
public Task <CreateServerResponse> CreateServer(string name, string region)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
if (region == null)
{
throw new ArgumentNullException(nameof(region));
}
var request = new CreateServerRequest {
Name = name, Region = region
};
return(_rest.Post <CreateServerResponse>(Endpoints.Servers, request));
}
/// <summary>
/// Adds a new server.
/// </summary>
public CreateServerResponse Create(CreateServerRequest server)
{
try
{
var request = new RestRequest("/servers", Method.POST)
{
RequestFormat = DataFormat.Json,
JsonSerializer = new CustomSerializer()
};
request.AddBody(server);
var result = restclient.Execute <CreateServerResponse>(request);
if (result.StatusCode != HttpStatusCode.Accepted)
{
throw new Exception(result.Content);
}
return(result.Data);
}
catch
{
throw;
}
}
public async Task <ServerDetailsResponse> CreateServerAsync([FromBody] CreateServerRequest request)
{
try
{
AbstractServerConfiguration configuration = null;
if (request.ConfigurationType == typeof(MinecraftConfiguration))
{
configuration = JsonHelper.Deserialise <MinecraftConfiguration>(request.JsonConfiguration);
}
else if (request.ConfigurationType == typeof(TerrariaConfiguration))
{
configuration = JsonHelper.Deserialise <TerrariaConfiguration>(request.JsonConfiguration);
}
if (configuration != null)
{
var server = await _servers.CreateServerFromConfigurationAsync(configuration);
return(new ServerDetailsResponse
{
Success = true,
Server = new ServerExtendedDetails(server, await CreateContainerDetailsForServer(server))
});
}
throw new Exception($"Unsupported configuration: {request.ConfigurationTypeName}");
}
catch (Exception exception)
{
_logger.LogError($"Failed to create new server: {exception.Message}");
return(new ServerDetailsResponse
{
Success = false,
Error = $"Failed to create new server: {exception.Message}"
});
}
}
/// <inheritdoc />
public NewServer CreateServer(string cloudServerName, string imageName, string flavor, string diskConfig = null, Metadata metadata = null, Personality[] personality = null, bool attachToServiceNetwork = false, bool attachToPublicNetwork = false, IEnumerable <Guid> networks = null, string region = null, CloudIdentity identity = null)
{
var urlPath = new Uri(string.Format("{0}/servers", GetServiceEndpoint(identity, region)));
NewServerNetwork[] networksToAttach = null;
var networkList = new List <NewServerNetwork>();
if (attachToServiceNetwork || attachToPublicNetwork)
{
if (attachToPublicNetwork)
{
networkList.Add(new NewServerNetwork {
Id = new Guid("00000000-0000-0000-0000-000000000000")
});
}
if (attachToServiceNetwork)
{
networkList.Add(new NewServerNetwork {
Id = new Guid("11111111-1111-1111-1111-111111111111")
});
}
}
if (networks != null && networks.Any())
{
networkList.AddRange(networks.Select(id => new NewServerNetwork()
{
Id = id
}));
}
if (networkList.Any())
{
networksToAttach = networkList.ToArray();
}
var request = new CreateServerRequest
{
Details = new CreateServerDetails
{
Name = cloudServerName,
DiskConfig = diskConfig,
Flavor = flavor,
ImageName = imageName,
Metadata = metadata,
Networks = networksToAttach,
Personality = personality,
}
};
var response = ExecuteRESTRequest <CreateServerResponse>(identity, urlPath, HttpMethod.POST, request);
if (response == null || response.Data == null || response.Data.Server == null)
{
return(null);
}
if (response.StatusCode != 200 && response.StatusCode != 202)
{
return(null); // throw new ExternalServiceException(response.StatusCode, response.Status, response.RawBody);
}
return(BuildCloudServersProviderAwareObject <NewServer>(response.Data.Server, region, identity));
}
public Task <ServerDetailsResponse> CreateServerAsync(CreateServerRequest request) =>
Client
.PostAsync <ServerDetailsResponse>(GetRelativeUrl(ServerApiRoutes.CreateServer), request)
.ValidateApiResponse("Failed to create new server");
