protected override void OnConnectCallback(IAsyncResult result)
{
if (Disposed)
{
return;
}
var server = (Socket)result.AsyncState;
try
{
//Client is connected to server and set connected variable
server.EndConnect(result);
ConnectedMre.Set();
KeepAliveTimer.Enabled = true;
var state = new ClientMetadata(Listener);
Receive(state);
}
catch (ObjectDisposedException ex)
{
RaiseErrorThrown(ex);
}
catch (SocketException)
{
Thread.Sleep(ReconnectInSeconds * 1000);
if (!Token.IsCancellationRequested && !Disposed)
{
Listener.BeginConnect(Endpoint, OnConnectCallback, Listener);
}
}
catch (Exception ex)
{
throw new Exception(ex.Message, ex);
}
}
public SessionLog(Guid sessionId, ClientMetadata metadata, DateTime startDate)
{
this.SessionId = sessionId;
this.Metadata = metadata;
StartDate = startDate;
EndDate = StartDate;
}
private void readCalMenuItem_Click(object sender, EventArgs e)
{
//fetch selected username
string username = treeView1.SelectedNode.Text;
if (username.Equals("Servers") || username.Equals("Clients"))
{
return;
}
string parent = treeView1.SelectedNode.Parent.Text;
if (parent.Equals("Servers"))
{
MessageBox.Show("You are messing with me rite?");
}
else if (parent.Equals("Clients"))
{
ClientMetadata cm = (ClientMetadata)pms.getClientsList()[username];
IClientFacade fs = (IClientFacade)pms.getClientFacadeList()[username];
List <CalendarSlot> calendar = fs.ReadCalendar();
show("Calendar for " + username + ":");
foreach (CalendarSlot slot in calendar)
{
show(slot);
}
}
else
{
return;
}
}
public void OurLookupAsyncCallBack(IAsyncResult ar)
{
Monitor.Enter(this);
try
{
try
{
RemoteLookupDelegate del = (RemoteLookupDelegate)((AsyncResult)ar).AsyncDelegate;
data = del.EndInvoke(ar);
Console.WriteLine("\nSIGNALLED STATUS");
waiter.Set();
Thread.Sleep(WAIT_TIME);
}
catch (Exception e)
{
Console.WriteLine("Exception" + e.Message);
data = null;
Console.WriteLine("\nFAILURE SIGNALLED STATUS");
waiter.Set();
Thread.Sleep(WAIT_TIME);
}
return;
}
finally
{
Monitor.Exit(this);
}
}
protected override void OnClientConnect(IAsyncResult result)
{
try
{
IClientMetadata state;
int id;
lock (ConnectedClients)
{
id = !ConnectedClients.Any() ? 1 : ConnectedClients.Keys.Max() + 1;
state = new ClientMetadata(((Socket)result.AsyncState).EndAccept(result), id);
CanAcceptConnections.Set();
ConnectedClients.Add(id, state);
}
//If the server shouldn't accept the IP do nothing.
if (!IsConnectionAllowed(state))
{
Log("A blacklisted ip tried to connect to the server: ipv4:" + state.RemoteIPv4 + " ipv6: " + state.RemoteIPv6);
lock (ConnectedClients)
{
ConnectedClients.Remove(id);
}
return;
}
Task.Run(() =>
{
var stream = new NetworkStream(state.Listener);
//Create SslStream
state.SslStream = new SslStream(stream, false, AcceptCertificate);
var success = Authenticate(state).Result;
if (success)
{
RaiseClientConnected(state);
Receive(state);
}
else
{
lock (ConnectedClients)
{
ConnectedClients.Remove(id);
}
Log("Unable to authenticate server.");
}
}, new CancellationTokenSource(10000).Token);
}
catch (Exception ex)
{
CanAcceptConnections.Set();
RaiseLog(ex);
RaiseErrorThrown(ex);
}
}
public void CurrentDirectoryTest()
{
ClientMetadata target = new ClientMetadata();
string expected = @"c:\Windows\System32";
string actual;
target.CurrentDirectory = expected;
actual = target.CurrentDirectory;
Assert.AreEqual(expected, actual);
}
public void AddressTest()
{
ClientMetadata target = new ClientMetadata();
string expected = "10.0.102.80:18020";
string actual;
target.Address = expected;
actual = target.Address;
Assert.AreEqual(expected, actual);
}
public void RootTest()
{
ClientMetadata target = new ClientMetadata();
string expected = "P4V";
string actual;
target.Name = expected;
actual = target.Name;
Assert.AreEqual(expected, actual);
}
public void NameTest()
{
ClientMetadata target = new ClientMetadata();
string expected = @"c:\Perforce";
string actual;
target.Name = expected;
actual = target.Name;
Assert.AreEqual(expected, actual);
}
/// <summary>
/// Receiving constructor
/// </summary>
/// <param name="state"></param>
/// <param name="socket"></param>
/// <param name="debug"></param>
internal SimpleMessage(ClientMetadata state, SimpleSocket socket, bool debug = false)
{
Metadata = new byte[0];
Header = new byte[0];
Data = new byte[0];
_debug = debug;
_state = state;
_socket = socket;
}
public void HostNameTest()
{
ClientMetadata target = new ClientMetadata();
string expected = "win-perforce";
string actual;
target.HostName = expected;
actual = target.HostName;
Assert.AreEqual(expected, actual);
}
public ActionResult Index(ClientMetadata _client)
{
if (ModelState.IsValid)
{
if (_loginApp.ValidateLogin(_client.Login, _client.Password))
{
FormsAuthentication.SetAuthCookie(_client.Login, false);
return(RedirectToAction("Index", "BankAccount"));
}
}
return(View());
}
/// <summary>
/// Create a Client Metadata Model.
/// </summary>
/// <param name="this">
/// A <see cref="ClientMetadata" />.
/// </param>
/// <returns>
/// A <see cref="ClientMetadataModel" /> if <paramref name="this" /> is not a null reference. A null
/// reference otherwise.
/// </returns>
internal static ClientMetadataModel AsClientMetadataModel(this ClientMetadata @this)
{
ClientMetadataModel clientMetadataModel = null;
if (@this != null)
{
clientMetadataModel = new ClientMetadataModel();
clientMetadataModel.Id = @this.Id;
clientMetadataModel.Version = @this.Version.ToString(3);
}
return(clientMetadataModel);
}
protected override void OnClientConnect(IAsyncResult result)
{
if (Token.IsCancellationRequested)
{
return;
}
CanAcceptConnections.Set();
try
{
IClientMetadata state;
lock (ConnectedClients)
{
var id = !ConnectedClients.Any() ? 1 : ConnectedClients.Keys.Max() + 1;
state = new ClientMetadata(((Socket)result.AsyncState).EndAccept(result), id);
//If the server shouldn't accept the IP do nothing.
if (!IsConnectionAllowed(state))
{
return;
}
var client = ConnectedClients.FirstOrDefault(x => x.Value == state);
if (client.Value == state)
{
id = client.Key;
ConnectedClients.Remove(id);
ConnectedClients.Add(id, state);
}
else
{
ConnectedClients.Add(id, state);
}
RaiseClientConnected(state);
}
Receive(state);
}
catch (ObjectDisposedException ode)
{
RaiseErrorThrown(ode);
}
catch (SocketException se)
{
RaiseErrorThrown(se);
}
}
public bool WriteClientMetadata(ClientMetadata clientInfo)
{
Monitor.Enter(this);
try
{
_clients[clientInfo.Username] = clientInfo;
Log.Show(_username, "[REGISTER CLIENT WRITE] Client info registered for " + clientInfo.Username);
return(true);
}
finally
{
Monitor.Exit(this);
}
}
private bool CompareValues(ClientMetadata myValue, ClientMetadata receivedValue)
{
if ((myValue == null) || (receivedValue == null))
{
return(false);
}
if ((myValue.Username.Equals(receivedValue.Username)) && (myValue.IP_Addr.Equals(receivedValue.IP_Addr)) && (myValue.Port.Equals(receivedValue.Port)))
{
return(true);
}
else
{
return(false);
}
}
private bool RegisterInfoOnAllServer(ClientMetadata client)
{
IConsistencyService[] server = new IConsistencyService[_servers.Count];
for (int i = 0; i < _servers.Count; i++)
{
server[i] = getOtherServers(_servers[i]);
}
callback returnedValueOnRegister1 = new callback();
callback.RemoteAsyncDelegate RemoteDelforRegister1 = new callback.RemoteAsyncDelegate(() => server[0].WriteClientMetadata(client));
AsyncCallback RemoteCallbackOnRegister1 = new AsyncCallback(returnedValueOnRegister1.OurRemoteAsyncCallBack);
IAsyncResult RemArForRegister1 = RemoteDelforRegister1.BeginInvoke(RemoteCallbackOnRegister1, null);
callback.RemoteAsyncDelegate RemoteDelforRegister2 = new callback.RemoteAsyncDelegate(() => server[1].WriteClientMetadata(client));
IAsyncResult RemArForRegister2 = RemoteDelforRegister2.BeginInvoke(RemoteCallbackOnRegister1, null);
action.WriteClientMetadata(client); //First Self Register
Log.Show(_username, "[REGISTER CLIENT] Registered on self!!");
Log.Show(_username, "[REGISTER CLIENT] Waiting for atleast one Server to return");
returnedValueOnRegister1.waiter.WaitOne();
//returnedValueOnRegister1.waiter.Reset();
if (returnedValueOnRegister1._status == false)
{
Log.Show(_username, "[REGISTER CLIENT] One of the Servers failed to register");
returnedValueOnRegister1.waiter.WaitOne();
// returnedValueOnRegister1.waiter.Reset();
if (returnedValueOnRegister1._status == false)
{
Log.Show(_username, "[REGISTER CLIENT] Both the Servers failed to register");
return(false);
}
else
{
Log.Show(_username, "[REGISTER CLIENT] One Server successfully registered");
return(true);
}
}
else
{
Log.Show(_username, "[REGISTER CLIENT] One Server successfully registered");
return(true);
}
}
protected override async void OnConnectCallback(IAsyncResult result)
{
var client = (Socket)result.AsyncState;
try
{
//Client is connected to server and set connected variable
client.EndConnect(result);
var stream = new NetworkStream(Listener);
_sslStream = new SslStream(stream, false, ValidateCertificate, null);
var success = await Authenticate(_sslStream);
if (success)
{
ConnectedMre.Set();
KeepAliveTimer.Enabled = true;
var state = new ClientMetadata(Listener);
Receive(state);
}
else
{
throw new AuthenticationException("Client cannot be authenticated.");
}
}
catch (SocketException)
{
ConnectedMre.Reset();
DisposeSslStream();
Thread.Sleep(ReconnectInSeconds * 1000);
if (Listener != null && !Disposed)
{
Listener.BeginConnect(Endpoint, OnConnectCallback, Listener);
}
else if (Listener == null && !Disposed)
{
StartClient(Ip, Port, ReconnectInSeconds);
}
}
catch (Exception ex)
{
RaiseErrorThrown(ex);
// throw new Exception(ex.Message, ex);
}
}
private IBookingService LookupClientStub(string userID)
{
ClientMetadata clientMd = null;
bool contacted = false;
while (!contacted)
{
try
{
//TODO: Navaneeth: here
Log.Show(_userName, "#1");
clientMd = _activeServer.Lookup(userID);
Log.Show(_userName, "#2");
contacted = true;
}
catch (Exception)
{
//server has failed
//update server reference
_activeServer = Helper.GetRandomServer(_servers);
}
}
IBookingService client = null;
if (clientMd != null)
{
String connectionString = "tcp://" + clientMd.IP_Addr + ":" + clientMd.Port + "/" + clientMd.Username + "/" + Common.Constants.BOOKING_SERVICE_NAME;
//Log.Debug(_userName, "Looking up participant stub: " + connectionString);
try
{
client = (IBookingService)Activator.GetObject(
typeof(ILookupService),
connectionString);
}
catch (SocketException e)
{
Log.Show(_userName, "ERROR: Could not connect to client: " + clientMd.Username + ". Exception: " + e);
//TODO: do something?
}
}
return(client);
}
public static void CreateNewKey(string projectId, string label, string description, string value)
{
CheckForInitAndLoginSDK();
Project project = GetProjectById(projectId);
var clientMetadata = new ClientMetadata
{
Label = label,
Description = description,
Locked = false
};
CellInfo createdKey = project.DataTable.CreateCell(value, clientMetadata);
Console.WriteLine("New key '{0}' was created.", createdKey.ClientMetadata.Label);
}
protected override void OnConnectCallback(IAsyncResult result)
{
if (Disposed)
{
return;
}
var server = (Socket)result.AsyncState;
try
{
//Client is connected to server and set connected variable
server.EndConnect(result);
ConnectedMre.Set();
KeepAliveTimer.Enabled = true;
var state = new ClientMetadata(Listener);
Receive(state);
}
catch (ObjectDisposedException ex)
{
RaiseErrorThrown(ex);
}
catch (SocketException)
{
if (Disposed)
{
return;
}
ConnectedMre.Reset();
Thread.Sleep(ReconnectInSeconds * 1000);
if (Listener != null && !Disposed)
{
Listener.BeginConnect(Endpoint, OnConnectCallback, Listener);
}
else if (Listener == null && !Disposed)
{
StartClient(Ip, Port, ReconnectInSeconds);
}
}
catch (Exception ex)
{
RaiseErrorThrown(ex);
}
}
void ILookupService.RegisterUser(string username, string ip, int port)
{
Monitor.Enter(this);
try
{
ClientMetadata client = new ClientMetadata();
client.IP_Addr = ip;
client.Port = port;
client.Username = username;
RegisterInfoOnAllServer(client);
Log.Show(_username, "Registered client " + username + ": " + ip + ":" + port);
pms.show("[REGISTER USER]" + _username + "-Registered client " + username + ": " + ip + ":" + port);
}
finally
{
Monitor.Exit(this);
}
}
//used for adding clients in the treeview
public void updateClientsTree(object sender, EventArgs ea)
{
if (InvokeRequired)
{
Invoke(new Action <object, EventArgs>(updateClientsTree), sender, ea);
return;
}
ClientMetadata cm = (ClientMetadata)sender;
TreeNode newNode = new TreeNode(cm.Username);
newNode.Name = cm.Username;
int index = treeView1.Nodes.IndexOfKey("Clients");
treeView1.Nodes[index].Nodes.Insert(0, newNode);
newNode.Parent.Expand();
show(cm.Username + " (" + cm.IP_Addr + ":" + cm.Port + ") just came online");
}
public void GetClientMetadataTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "******";
string pass = string.Empty;
string ws_client = "admin_space";
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
Process p4d = Utilities.DeployP4TestServer(TestDir, 8, unicode);
Server server = new Server(new ServerAddress(uri));
try
{
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
bool connected = con.Connect(null);
Assert.IsTrue(connected);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
ClientMetadata c = rep.GetClientMetadata();
Assert.IsNotNull(c);
string machinename = System.Environment.MachineName;
Assert.IsTrue(c.HostName.ToLower().Contains(machinename.ToLower()));
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
public bool registerClient(string username, string ip_addr, int port)
{
//creating a ClientMetadata object to store client information
ClientMetadata cm = new ClientMetadata();
cm.Username = username;
cm.IP_Addr = ip_addr;
cm.Port = port;
//adding the client metadata to the global hashtable so that it can be used later on
clients_list.Add(username, cm);
IClientFacade facadeService = connectToClientFacadeService(cm);
clientFacadeList.Add(username, facadeService);
//update the Clients tree in PuppetGUI
Gui.updateClientsTree(cm, null);
return(true);
}
private IClientFacade connectToClientFacadeService(ClientMetadata cm)
{
//connect to PuppetMaster here
String connectionString = "tcp://" + cm.IP_Addr + ":" + cm.Port + "/" + cm.Username + "/" + Common.Constants.CLIENT_FACADE_SERVICE;
IDictionary RemoteChannelProperties = new Dictionary <string, string>();
RemoteChannelProperties["name"] = cm.Username;
TcpChannel client_channel = new TcpChannel(RemoteChannelProperties, null, null);
ChannelServices.RegisterChannel(client_channel, true);
//TODO: uncomment and fix this to make it work
IClientFacade facadeService = (IClientFacade)Activator.GetObject(
typeof(IClientFacade),
connectionString);
return(facadeService);
}
private void connectMenuItem_Click(object sender, EventArgs e)
{
//fetch selected username
string username = treeView1.SelectedNode.Text;
if (username.Equals("Servers") || username.Equals("Clients"))
{
return;
}
string parent = treeView1.SelectedNode.Parent.Text;
if (parent.Equals("Servers"))
{
ServerMetadata sm = (ServerMetadata)pms.getServersList()[username];
IServerFacade isf = (IServerFacade)pms.getServerFacadeList()[username];
isf.Connect(); /*commented because Server Facade is not implemented yet*/
//show(username + " is now connected");
treeView1.SelectedNode.ImageIndex = 0;
treeView1.SelectedNode.SelectedImageIndex = 0;
}
else if (parent.Equals("Clients"))
{
ClientMetadata cm = (ClientMetadata)pms.getClientsList()[username];
IClientFacade fs = (IClientFacade)pms.getClientFacadeList()[username];
fs.Connect(); //EXCEPTION UNHANDLED - WASIF CHECK THIS
show(username + " has been connected");
treeView1.SelectedNode.ImageIndex = 0;
treeView1.SelectedNode.SelectedImageIndex = 0;
}
else
{
return;
}
}
public async Task <IActionResult> NewSession([FromBody] ClientMetadata metadata)
{
if (ModelState.IsValid)
{
var sessionId = Guid.NewGuid();
await logger.Log(
LogLevel.Information,
new LoggerTag(
sessionId,
ImmutableList <LogTag> .Empty,
metadata
),
new LogEntry("Session started", DateTime.Now)
);
Response.Cookies.Append("sessionId", sessionId.ToString());
return(Ok());
}
else
{
return(BadRequest());
}
}
/// <summary>
/// Receiving constructor
/// </summary>
/// <param name="state"></param>
/// <param name="socket"></param>
/// <param name="debug"></param>
internal SimpleMessage(ClientMetadata state, SimpleSocket socket, bool debug = false)
{
_debug = debug;
_state = state;
_socket = socket;
}
public LoggerTag(Guid sessionId, IImmutableList <LogTag> tagPath, ClientMetadata clientMetadata)
{
SessionId = sessionId;
TagPath = tagPath;
ClientMetadata = clientMetadata;
}
